<?xml version='1.0' encoding='UTF-8'?>
<!DOCTYPE html PUBLIC '-//W3C//DTD XHTML 1.0 Transitional//EN' 'http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd'>
<html dir="ltr" xmlns="http://www.w3.org/1999/xhtml">
<head>
<title>JSON-LD 1.0</title>
<meta http-equiv="content-type" content="text/html; charset=UTF-8" />

<!--  
  === NOTA BENE ===
  For the three scripts below, if your spec resides on dev.w3 you can check them
  out in the same tree and use relative links so that they'll work offline,
   -->



<style>
.diff { font-weight:bold; color:#0a3; }
ol.algorithm.update { margin-left: 2em; }
ol.algorithm.update>li { list-style-type: none; }
ol.algorithm.update>li>span.list-number {
  display:block;
  float: left; 
  margin-left: -3.5em;
}
</style>
<style type="text/css">
/*****************************************************************
 * ReSpec CSS
 * Robin Berjon (robin at berjon dot com)
 * v0.05 - 2009-07-31
 *****************************************************************/


/* --- INLINES --- */
em.rfc2119 { 
    text-transform:     lowercase;
    font-variant:       small-caps;
    font-style:         normal;
    color:              #900;
}

h1 acronym, h2 acronym, h3 acronym, h4 acronym, h5 acronym, h6 acronym, a acronym,
h1 abbr, h2 abbr, h3 abbr, h4 abbr, h5 abbr, h6 abbr, a abbr {
    border: none;
}

dfn {
    font-weight:    bold;
}

a.internalDFN {
    color:  inherit;
    border-bottom:  1px solid #99c;
    text-decoration:    none;
}

a.externalDFN {
    color:  inherit;
    border-bottom:  1px dotted #ccc;
    text-decoration:    none;
}

a.bibref {
    text-decoration:    none;
}

code {
    color:  #ff4500;
}


/* --- WEB IDL --- */
pre.idl {
    border-top: 1px solid #90b8de;
    border-bottom: 1px solid #90b8de;
    padding:    1em;
    line-height:    120%;
}

pre.idl::before {
    content:    "WebIDL";
    display:    block;
    width:      150px;
    background: #90b8de;
    color:  #fff;
    font-family:    initial;
    padding:    3px;
    font-weight:    bold;
    margin: -1em 0 1em -1em;
}

.idlType {
    color:  #ff4500;
    font-weight:    bold;
    text-decoration:    none;
}

/*.idlModule*/
/*.idlModuleID*/
/*.idlInterface*/
.idlInterfaceID {
    font-weight:    bold;
    color:  #005a9c;
}

.idlSuperclass {
    font-style: italic;
    color:  #005a9c;
}

/*.idlAttribute*/
.idlAttrType, .idlFieldType {
    color:  #005a9c;
}
.idlAttrName, .idlFieldName {
    color:  #ff4500;
}
.idlAttrName a, .idlFieldName a {
    color:  #ff4500;
    border-bottom:  1px dotted #ff4500;
    text-decoration: none;
}

/*.idlMethod*/
.idlMethType {
    color:  #005a9c;
}
.idlMethName {
    color:  #ff4500;
}
.idlMethName a {
    color:  #ff4500;
    border-bottom:  1px dotted #ff4500;
    text-decoration: none;
}

/*.idlParam*/
.idlParamType {
    color:  #005a9c;
}
.idlParamName {
    font-style: italic;
}

.extAttr {
    color:  #666;
}

/*.idlConst*/
.idlConstType {
    color:  #005a9c;
}
.idlConstName {
    color:  #ff4500;
}
.idlConstName a {
    color:  #ff4500;
    border-bottom:  1px dotted #ff4500;
    text-decoration: none;
}

/*.idlException*/
.idlExceptionID {
    font-weight:    bold;
    color:  #c00;
}

.idlTypedefID, .idlTypedefType {
    color:  #005a9c;
}

.idlRaises, .idlRaises a.idlType, .idlRaises a.idlType code, .excName a, .excName a code {
    color:  #c00;
    font-weight:    normal;
}

.excName a {
    font-family:    monospace;
}

.idlRaises a.idlType, .excName a.idlType {
    border-bottom:  1px dotted #c00;
}

.excGetSetTrue, .excGetSetFalse, .prmNullTrue, .prmNullFalse, .prmOptTrue, .prmOptFalse {
    width:  45px;
    text-align: center;
}
.excGetSetTrue, .prmNullTrue, .prmOptTrue { color:  #0c0; }
.excGetSetFalse, .prmNullFalse, .prmOptFalse { color:  #c00; }

.idlImplements a {
    font-weight:    bold;
}

dl.attributes, dl.methods, dl.constants, dl.fields {
    margin-left:    2em;
}

.attributes dt, .methods dt, .constants dt, .fields dt {
    font-weight:    normal;
}

.attributes dt code, .methods dt code, .constants dt code, .fields dt code {
    font-weight:    bold;
    color:  #000;
    font-family:    monospace;
}

.attributes dt code, .fields dt code {
    background:  #ffffd2;
}

.attributes dt .idlAttrType code, .fields dt .idlFieldType code {
    color:  #005a9c;
    background:  transparent;
    font-family:    inherit;
    font-weight:    normal;
    font-style: italic;
}

.methods dt code {
    background:  #d9e6f8;
}

.constants dt code {
    background:  #ddffd2;
}

.attributes dd, .methods dd, .constants dd, .fields dd {
    margin-bottom:  1em;
}

table.parameters, table.exceptions {
    border-spacing: 0;
    border-collapse:    collapse;
    margin: 0.5em 0;
    width:  100%;
}
table.parameters { border-bottom:  1px solid #90b8de; }
table.exceptions { border-bottom:  1px solid #deb890; }

.parameters th, .exceptions th {
    color:  #fff;
    padding:    3px 5px;
    text-align: left;
    font-family:    initial;
    font-weight:    normal;
    text-shadow:    #666 1px 1px 0;
}
.parameters th { background: #90b8de; }
.exceptions th { background: #deb890; }

.parameters td, .exceptions td {
    padding:    3px 10px;
    border-top: 1px solid #ddd;
    vertical-align: top;
}

.parameters tr:first-child td, .exceptions tr:first-child td {
    border-top: none;
}

.parameters td.prmName, .exceptions td.excName, .exceptions td.excCodeName {
    width:  100px;
}

.parameters td.prmType {
    width:  120px;
}

table.exceptions table {
    border-spacing: 0;
    border-collapse:    collapse;
    width:  100%;
}

/* --- TOC --- */
.toc a {
    text-decoration:    none;
}

a .secno {
    color:  #000;
}

/* --- TABLE --- */
table.simple {
    border-spacing: 0;
    border-collapse:    collapse;
    border-bottom:  3px solid #005a9c;
}

.simple th {
    background: #005a9c;
    color:  #fff;
    padding:    3px 5px;
    text-align: left;
}

.simple th[scope="row"] {
    background: inherit;
    color:  inherit;
    border-top: 1px solid #ddd;
}

.simple td {
    padding:    3px 10px;
    border-top: 1px solid #ddd;
}

.simple tr:nth-child(even) {
    background: #f0f6ff;
}

/* --- DL --- */
.section dd > p:first-child {
    margin-top: 0;
}

.section dd > p:last-child {
    margin-bottom: 0;
}

.section dd {
    margin-bottom:  1em;
}

.section dl.attrs dd, .section dl.eldef dd {
    margin-bottom:  0;
}

/* --- EXAMPLES --- */
pre.example {
    border-top: 1px solid #ff4500;
    border-bottom: 1px solid #ff4500;
    padding:    1em;
    margin-top: 1em;
}

pre.example::before {
    content:    "Example";
    display:    block;
    width:      150px;
    background: #ff4500;
    color:  #fff;
    font-family:    initial;
    padding:    3px;
    font-weight:    bold;
    margin: -1em 0 1em -1em;
}

/* --- EDITORIAL NOTES --- */
.issue {
    padding:    1em;
    margin: 1em 0em 0em;
    border: 1px solid #f00;
    background: #ffc;
}

.issue::before {
    content:    "Issue";
    display:    block;
    width:  150px;
    margin: -1.5em 0 0.5em 0;
    font-weight:    bold;
    border: 1px solid #f00;
    background: #fff;
    padding:    3px 1em;
}

.note {
    margin: 1em 0em 0em;
    padding:    1em;
    border: 2px solid #cff6d9;
    background: #e2fff0;
}

.note::before {
    content:    "Note";
    display:    block;
    width:  150px;
    margin: -1.5em 0 0.5em 0;
    font-weight:    bold;
    border: 1px solid #cff6d9;
    background: #fff;
    padding:    3px 1em;
}

/* --- Best Practices --- */
div.practice {
    border: solid #bebebe 1px;
    margin: 2em 1em 1em 2em;
}

span.practicelab {
    margin: 1.5em 0.5em 1em 1em;
    font-weight: bold;
    font-style: italic;
}

span.practicelab   { background: #dfffff; }

span.practicelab {
    position: relative;
    padding: 0 0.5em;
    top: -1.5em;
}

p.practicedesc {
    margin: 1.5em 0.5em 1em 1em;
}

@media screen {
    p.practicedesc {
        position: relative;
        top: -2em;
        padding: 0;
        margin: 1.5em 0.5em -1em 1em;
}

/* --- SYNTAX HIGHLIGHTING --- */
pre.sh_sourceCode {
  background-color: white;
  color: black;
  font-style: normal;
  font-weight: normal;
}

pre.sh_sourceCode .sh_keyword { color: #005a9c; font-weight: bold; }           /* language keywords */
pre.sh_sourceCode .sh_type { color: #666; }                            /* basic types */
pre.sh_sourceCode .sh_usertype { color: teal; }                             /* user defined types */
pre.sh_sourceCode .sh_string { color: red; font-family: monospace; }        /* strings and chars */
pre.sh_sourceCode .sh_regexp { color: orange; font-family: monospace; }     /* regular expressions */
pre.sh_sourceCode .sh_specialchar { color: 	#ffc0cb; font-family: monospace; }  /* e.g., \n, \t, \\ */
pre.sh_sourceCode .sh_comment { color: #A52A2A; font-style: italic; }         /* comments */
pre.sh_sourceCode .sh_number { color: purple; }                             /* literal numbers */
pre.sh_sourceCode .sh_preproc { color: #00008B; font-weight: bold; }       /* e.g., #include, import */
pre.sh_sourceCode .sh_symbol { color: blue; }                            /* e.g., *, + */
pre.sh_sourceCode .sh_function { color: black; font-weight: bold; }         /* function calls and declarations */
pre.sh_sourceCode .sh_cbracket { color: red; }                              /* block brackets (e.g., {, }) */
pre.sh_sourceCode .sh_todo { font-weight: bold; background-color: #00FFFF; }   /* TODO and FIXME */

/* Predefined variables and functions (for instance glsl) */
pre.sh_sourceCode .sh_predef_var { color: #00008B; }
pre.sh_sourceCode .sh_predef_func { color: #00008B; font-weight: bold; }

/* for OOP */
pre.sh_sourceCode .sh_classname { color: teal; }

/* line numbers (not yet implemented) */
pre.sh_sourceCode .sh_linenum { display: none; }

/* Internet related */
pre.sh_sourceCode .sh_url { color: blue; text-decoration: underline; font-family: monospace; }

/* for ChangeLog and Log files */
pre.sh_sourceCode .sh_date { color: blue; font-weight: bold; }
pre.sh_sourceCode .sh_time, pre.sh_sourceCode .sh_file { color: #00008B; font-weight: bold; }
pre.sh_sourceCode .sh_ip, pre.sh_sourceCode .sh_name { color: #006400; }

/* for Prolog, Perl... */
pre.sh_sourceCode .sh_variable { color: #006400; }

/* for LaTeX */
pre.sh_sourceCode .sh_italics { color: #006400; font-style: italic; }
pre.sh_sourceCode .sh_bold { color: #006400; font-weight: bold; }
pre.sh_sourceCode .sh_underline { color: #006400; text-decoration: underline; }
pre.sh_sourceCode .sh_fixed { color: green; font-family: monospace; }
pre.sh_sourceCode .sh_argument { color: #006400; }
pre.sh_sourceCode .sh_optionalargument { color: purple; }
pre.sh_sourceCode .sh_math { color: orange; }
pre.sh_sourceCode .sh_bibtex { color: blue; }

/* for diffs */
pre.sh_sourceCode .sh_oldfile { color: orange; }
pre.sh_sourceCode .sh_newfile { color: #006400; }
pre.sh_sourceCode .sh_difflines { color: blue; }

/* for css */
pre.sh_sourceCode .sh_selector { color: purple; }
pre.sh_sourceCode .sh_property { color: blue; }
pre.sh_sourceCode .sh_value { color: #006400; font-style: italic; }

/* other */
pre.sh_sourceCode .sh_section { color: black; font-weight: bold; }
pre.sh_sourceCode .sh_paren { color: red; }
pre.sh_sourceCode .sh_attribute { color: #006400; }

</style><style type="text/css">ol.algorithm { counter-reset:numsection; list-style-type: none; }
ol.algorithm li { margin: 0.5em 0; }
ol.algorithm li:before { font-weight: bold; counter-increment: numsection; content: counters(numsection, ".") ") "; }

</style><link href="http://www.w3.org/StyleSheets/TR/w3c-unofficial" rel="stylesheet" type="text/css" charset="utf-8" /><style type='text/css'>
.diff-old-a {
  font-size: smaller;
  color: red;
}

.diff-new { background-color: yellow; }
.diff-chg { background-color: lime; }
.diff-new:before,
.diff-new:after
    { content: "\2191" }
.diff-chg:before, .diff-chg:after
    { content: "\2195" }
.diff-old { text-decoration: line-through; background-color: #FBB; }
.diff-old:before,
.diff-old:after
    { content: "\2193" }
:focus { border: thin red solid}
</style>
</head>


<body style="display: inherit; ">
<div class="head">
<p>
</p>
<h1 class="title" id="title">
JSON-LD
<del class="diff-old">-
Linked
Data
Expression
in
JSON
</del>
<ins class="diff-chg">1.0
</ins>
</h1>
<h2 id="subtitle">
A
Context-based
JSON
Serialization
for
<del class="diff-old">Linked
</del>
<ins class="diff-chg">Linking
</ins>
Data
</h2>
<h2 id="unofficial-draft-08-august-2011">
Unofficial
Draft
<del class="diff-old">15
June
</del>
<ins class="diff-chg">08
August
</ins>
2011
</h2>
<dl>
<dt>
Editors:
</dt>
<dd>
<a href="http://manu.sporny.org/">
Manu
Sporny
</a>,
<a href="http://digitalbazaar.com/">
Digital
<del class="diff-old">Bazaar,
Inc.
</del>
<ins class="diff-chg">Bazaar
</ins>
</a>
</dd>
<dd>
<a href="http://greggkellogg.net/">
Gregg
Kellogg
</a>,
Kellogg
Associates
</dd>
<dt>
Authors:
</dt>
<dd>
<del class="diff-old">Mark
Birbeck
</del>
<a href="http://digitalbazaar.com/">
<ins class="diff-chg">Manu
Sporny
</ins>
</a>,
<del class="diff-old">Backplane
Ltd.
</del>
<a href="http://digitalbazaar.com/">
<ins class="diff-chg">Digital
Bazaar
</ins>
</a>
</dd>
<dd>
<a href="http://greggkellogg.net/">
<ins class="diff-new">Gregg
Kellogg
</ins></a>,<ins class="diff-new">
Kellogg
Associates
</ins></dd><dd>
<a href="http://digitalbazaar.com/">
<del class="diff-old">Manu
Sporny
</del>
<ins class="diff-chg">Dave
Longley
</ins>
</a>,
<a href="http://digitalbazaar.com/">
Digital
<del class="diff-old">Bazaar,
Inc.
</del>
<ins class="diff-chg">Bazaar
</ins></a></dd><dd><a href="http://webbackplane.com/"><ins class="diff-chg">
Mark
Birbeck
</ins></a>,<a href="http://webbackplane.com/"><ins class="diff-chg">
Backplane
Ltd.
</ins>
</a>
</dd>
</dl>
<p>
This
document
is
also
available
in
this
non-normative
format:
<a href="diff-20110615.html">
diff
to
previous
version
</a>.
</p>
<p class="copyright">
This
document
is
licensed
under
a
<a class="subfoot" href="http://creativecommons.org/licenses/by/3.0/" rel="license">
Creative
Commons
Attribution
3.0
License
</a>.
</p>
<hr />
</div>
<div id="abstract" class="introductory section">
<h2>
Abstract
</h2>
<p>
<del class="diff-old">Developers
that
embed
structured
data
in
their
Web
pages
can
choose
among
a
number
of
languages
such
as
RDFa
[
RDFA-CORE
],
Microformats
</del>
<ins class="diff-chg">JSON
</ins>
[
<cite>
<del class="diff-old">MICROFORMATS
</del>
<a class="bibref" rel="biblioentry" href="#bib-RFC4627">
<ins class="diff-chg">RFC4627
</ins>
</a>
</cite>
]
<del class="diff-old">and
Microdata
[
MICRODATA
].
Each
of
these
structured
data
languages,
while
incompatible
at
the
syntax
level,
can
be
easily
mapped
to
RDF.
JSON
</del>
has
proven
to
be
a
highly
useful
object
serialization
and
messaging
format.
In
an
attempt
to
harmonize
the
representation
of
Linked
Data
in
JSON,
this
specification
outlines
a
common
JSON
representation
format
for
<ins class="diff-new">expressing
directed
graphs;
mixing
both
</ins>
Linked
Data
<del class="diff-old">that
can
be
used
to
represent
objects
specified
via
RDFa,
Microformats
</del>
and
<del class="diff-old">Microdata.
</del>
<ins class="diff-chg">non-Linked
Data
in
a
single
document.
</ins>
</p>
</div>
<div id="sotd" class="introductory section">
<h2>
Status
of
This
Document
</h2>
<p>
This
document
is
merely
a
public
working
draft
of
a
potential
specification.
It
has
no
official
standing
of
any
kind
and
does
not
represent
the
support
or
consensus
of
any
standards
organisation.
</p>
<p>
This
document
is
an
experimental
work
in
progress.
</p>
</div>
<div id="toc" class="section">
<h2 class="introductory">
Table
of
Contents
</h2>
<ul class="toc">
<li class="tocline">
<a href="#introduction" class="tocxref">
<span class="secno">
1.
</span>
Introduction
</a>
<ul class="toc">
<li class="tocline">
<a href="#how-to-read-this-document" class="tocxref">
<span class="secno">
1.1
</span>
How
to
Read
this
Document
</a>
</li>
<li class="tocline">
<a href="#contributing" class="tocxref">
<span class="secno">
1.2
</span>
Contributing
</a>
</li>
</ul>
</li>
<li class="tocline">
<a href="#design" class="tocxref">
<span class="secno">
2.
</span>
Design
<del class="diff-old">Goals
and
Rationale
</del>
</a>
<ul class="toc">
<li class="tocline">
<a href="#goals-and-rationale" class="tocxref">
<span class="secno">
2.1
</span>
Goals
<ins class="diff-new">and
Rationale
</ins>
</a>
</li>
<li class="tocline">
<a href="#linked-data" class="tocxref">
<span class="secno">
2.2
</span>
<del class="diff-old">Map
Terms
to
IRIs
</del>
<ins class="diff-chg">Linked
Data
</ins>
</a>
</li>
<li class="tocline">
<a href="#linking-data" class="tocxref">
<span class="secno">
2.3
</span>
<del class="diff-old">The
JSON-LD
Context
</del>
<ins class="diff-chg">Linking
Data
</ins>
</a>
</li>
<li class="tocline">
<a href="#the-context" class="tocxref">
<span class="secno">
2.4
</span>
<del class="diff-old">Unambiguous
Identifiers
for
JSON
</del>
<ins class="diff-chg">The
Context
</ins>
</a>
<ul class="toc">
<li class="tocline">
<a href="#inside-a-context" class="tocxref">
<span class="secno">
<del class="diff-old">2.5
</del>
<ins class="diff-chg">2.4.1
</ins>
</span>
<del class="diff-old">Mashing
Up
Vocabularies
</del>
<ins class="diff-chg">Inside
a
Context
</ins>
</a>
</li>
</ul>
</li>
<li class="tocline">
<a href="#from-json-to-json-ld" class="tocxref">
<span class="secno">
<del class="diff-old">2.6
</del>
<ins class="diff-chg">2.5
</ins>
</span>
<del class="diff-old">An
Example
of
a
Context
</del>
<ins class="diff-chg">From
JSON
to
JSON-LD
</ins>
</a>
</li>
</ul>
</li>
<li class="tocline">
<a href="#basic-concepts" class="tocxref">
<span class="secno">
3.
</span>
<del class="diff-old">Markup
Examples
</del>
<ins class="diff-chg">Basic
Concepts
</ins>
</a>
<ul class="toc">
<li class="tocline">
<a href="#iris" class="tocxref">
<span class="secno">
3.1
</span>
<del class="diff-old">RDFa
</del>
<ins class="diff-chg">IRIs
</ins>
</a>
</li>
<li class="tocline">
<a href="#identifying-the-subject" class="tocxref">
<span class="secno">
3.2
</span>
<del class="diff-old">Microformats
</del>
<ins class="diff-chg">Identifying
the
Subject
</ins>
</a>
</li>
<li class="tocline">
<a href="#specifying-the-type" class="tocxref">
<span class="secno">
3.3
</span>
<del class="diff-old">Microdata
</del>
<ins class="diff-chg">Specifying
the
Type
</ins></a></li><li class="tocline"><a href="#strings" class="tocxref"><span class="secno"><ins class="diff-chg">
3.4
</ins></span><ins class="diff-chg">
Strings
</ins></a></li><li class="tocline"><a href="#string-internationalization" class="tocxref"><span class="secno"><ins class="diff-chg">
3.5
</ins></span><ins class="diff-chg">
String
Internationalization
</ins></a></li><li class="tocline"><a href="#datatypes" class="tocxref"><span class="secno"><ins class="diff-chg">
3.6
</ins></span><ins class="diff-chg">
Datatypes
</ins></a></li><li class="tocline"><a href="#multiple-objects-for-a-single-property" class="tocxref"><span class="secno"><ins class="diff-chg">
3.7
</ins></span><ins class="diff-chg">
Multiple
Objects
for
a
Single
Property
</ins></a></li><li class="tocline"><a href="#multiple-typed-literals-for-a-single-property" class="tocxref"><span class="secno"><ins class="diff-chg">
3.8
</ins></span><ins class="diff-chg">
Multiple
Typed
Literals
for
a
Single
Property
</ins></a></li><li class="tocline"><a href="#expansion" class="tocxref"><span class="secno"><ins class="diff-chg">
3.9
</ins></span><ins class="diff-chg">
Expansion
</ins></a></li><li class="tocline"><a href="#compaction" class="tocxref"><span class="secno"><ins class="diff-chg">
3.10
</ins></span><ins class="diff-chg">
Compaction
</ins></a></li><li class="tocline"><a href="#framing" class="tocxref"><span class="secno"><ins class="diff-chg">
3.11
</ins></span><ins class="diff-chg">
Framing
</ins>
</a>
</li>
</ul>
</li>
<li class="tocline">
<a href="#advanced-concepts" class="tocxref">
<span class="secno">
4.
</span>
<del class="diff-old">Markup
of
RDF
</del>
<ins class="diff-chg">Advanced
</ins>
Concepts
</a>
<ul class="toc">
<li class="tocline">
<a href="#automatic-typing" class="tocxref">
<span class="secno">
4.1
</span>
<del class="diff-old">IRIs
</del>
<ins class="diff-chg">Automatic
Typing
</ins>
</a>
</li>
<li class="tocline">
<a href="#type-coercion" class="tocxref">
<span class="secno">
4.2
</span>
<del class="diff-old">Identifying
the
Subject
</del>
<ins class="diff-chg">Type
Coercion
</ins>
</a>
</li>
<li class="tocline">
<a href="#chaining" class="tocxref">
<span class="secno">
4.3
</span>
<del class="diff-old">Specifying
the
Type
</del>
<ins class="diff-chg">Chaining
</ins>
</a>
</li>
<li class="tocline">
<a href="#identifying-unlabeled-nodes" class="tocxref">
<span class="secno">
4.4
</span>
<del class="diff-old">Plain
Literals
</del>
<ins class="diff-chg">Identifying
Unlabeled
Nodes
</ins>
</a>
</li>
<li class="tocline">
<a href="#overriding-keywords" class="tocxref">
<span class="secno">
4.5
</span>
<del class="diff-old">Language
Specification
in
Plain
Literals
</del>
<ins class="diff-chg">Overriding
Keywords
</ins>
</a>
</li>
<li class="tocline">
<a href="#normalization" class="tocxref">
<span class="secno">
4.6
</span>
<del class="diff-old">Typed
Literals
</del>
<ins class="diff-chg">Normalization
</ins>
</a>
</li>
</ul>
</li>
<li class="tocline">
<a href="#algorithms" class="tocxref">
<span class="secno">
<del class="diff-old">4.7
</del>
<ins class="diff-chg">5.
</ins>
</span>
<del class="diff-old">Multiple
Objects
for
a
Single
Property
</del>
<ins class="diff-chg">Algorithms
</ins></a><ul class="toc"><li class="tocline"><a href="#syntax-tokens-and-keywords" class="tocxref"><span class="secno"><ins class="diff-chg">
5.1
</ins></span><ins class="diff-chg">
Syntax
Tokens
and
Keywords
</ins>
</a>
</li>
<li class="tocline">
<a href="#algorithm-terms" class="tocxref">
<span class="secno">
<del class="diff-old">4.8
</del>
<ins class="diff-chg">5.2
</ins>
</span>
<del class="diff-old">Multiple
Typed
Literals
for
a
Single
Property
</del>
<ins class="diff-chg">Algorithm
Terms
</ins>
</a>
</li>
<li class="tocline">
<a href="#context-1" class="tocxref">
<span class="secno">
<del class="diff-old">4.9
</del>
<ins class="diff-chg">5.3
</ins>
</span>
<del class="diff-old">Blank
Nodes
</del>
<ins class="diff-chg">Context
</ins></a><ul class="toc"><li class="tocline"><a href="#coerce" class="tocxref"><span class="secno"><ins class="diff-chg">
5.3.1
</ins></span><ins class="diff-chg">
Coerce
</ins></a></li><li class="tocline"><a href="#initial-context" class="tocxref"><span class="secno"><ins class="diff-chg">
5.3.2
</ins></span><ins class="diff-chg">
Initial
Context
</ins>
</a>
</li>
</ul>
</li>
<li class="tocline">
<a href="#iri-expansion" class="tocxref">
<span class="secno">
<del class="diff-old">5.
</del>
<ins class="diff-chg">5.4
</ins>
</span>
<del class="diff-old">Advanced
Features
</del>
<ins class="diff-chg">IRI
Expansion
</ins>
</a>
</li>
<li class="tocline">
<a href="#iri-compaction" class="tocxref">
<span class="secno">
<del class="diff-old">5.1
</del>
<ins class="diff-chg">5.5
</ins>
</span>
<del class="diff-old">Automatic
Typing
</del>
<ins class="diff-chg">IRI
Compaction
</ins>
</a>
</li>
<li class="tocline">
<a href="#value-expansion" class="tocxref">
<span class="secno">
<del class="diff-old">5.2
</del>
<ins class="diff-chg">5.6
</ins>
</span>
<del class="diff-old">Type
Coercion
</del>
<ins class="diff-chg">Value
Expansion
</ins>
</a>
</li>
<li class="tocline">
<a href="#value-compaction" class="tocxref">
<span class="secno">
<ins class="diff-chg">5.7
</ins></span><ins class="diff-chg">
Value
Compaction
</ins></a>
</li>
<li class="tocline">
<a href="#expansion-1" class="tocxref">
<span class="secno">
<del class="diff-old">6.
</del>
<ins class="diff-chg">5.8
</ins>
</span>
<del class="diff-old">The
JSON-LD
Processing
</del>
<ins class="diff-chg">Expansion
</ins></a><ul class="toc"><li class="tocline"><a href="#expansion-algorithm" class="tocxref"><span class="secno"><ins class="diff-chg">
5.8.1
</ins></span><ins class="diff-chg">
Expansion
</ins>
Algorithm
</a>
</li>
</ul>
</li>
<li class="tocline">
<a href="#compaction-1" class="tocxref">
<span class="secno">
<ins class="diff-new">5.9
</ins></span><ins class="diff-new">
Compaction
</ins></a>
<ul class="toc">
<li class="tocline">
<a href="#compaction-algorithm" class="tocxref">
<span class="secno">
<del class="diff-old">6.1
</del>
<ins class="diff-chg">5.9.1
</ins>
</span>
<del class="diff-old">Overview
</del>
<ins class="diff-chg">Compaction
Algorithm
</ins>
</a>
</li>
</ul>
</li>
<li class="tocline">
<a href="#framing-1" class="tocxref">
<span class="secno">
<del class="diff-old">6.2
</del>
<ins class="diff-chg">5.10
</ins>
</span>
<del class="diff-old">Processing
</del>
<ins class="diff-chg">Framing
</ins></a><ul class="toc"><li class="tocline"><a href="#framing-algorithm-terms" class="tocxref"><span class="secno"><ins class="diff-chg">
5.10.1
</ins></span><ins class="diff-chg">
Framing
</ins>
Algorithm
Terms
</a>
</li>
<li class="tocline">
<a href="#framing-algorithm" class="tocxref">
<span class="secno">
<del class="diff-old">6.3
</del>
<ins class="diff-chg">5.10.2
</ins>
</span>
<del class="diff-old">Processing
Tokens
and
Keywords
</del>
<ins class="diff-chg">Framing
Algorithm
</ins>
</a>
</li>
</ul>
</li>
<li class="tocline">
<a href="#normalization-1" class="tocxref">
<span class="secno">
<del class="diff-old">6.4
</del>
<ins class="diff-chg">5.11
</ins>
</span>
<del class="diff-old">Context
</del>
<ins class="diff-chg">Normalization
</ins>
</a>
<ul class="toc">
<li class="tocline">
<a href="#normalization-algorithm-terms" class="tocxref">
<span class="secno">
<del class="diff-old">6.4.1
</del>
<ins class="diff-chg">5.11.1
</ins>
</span>
<del class="diff-old">Coerce
</del>
<ins class="diff-chg">Normalization
Algorithm
Terms
</ins>
</a>
</li>
<li class="tocline">
<a href="#normalization-algorithm" class="tocxref">
<span class="secno">
<ins class="diff-chg">5.11.2
</ins></span><ins class="diff-chg">
Normalization
Algorithm
</ins></a>
</li>
<li class="tocline">
<a href="#node-labeling-algorithm" class="tocxref">
<span class="secno">
<del class="diff-old">6.5
</del>
<ins class="diff-chg">5.11.3
</ins>
</span>
<del class="diff-old">Chaining
</del>
<ins class="diff-chg">Node
Labeling
Algorithm
</ins>
</a>
</li>
<li class="tocline">
<a href="#shallow-comparison-algorithm" class="tocxref">
<span class="secno">
<del class="diff-old">6.6
</del>
<ins class="diff-chg">5.11.4
</ins>
</span>
<del class="diff-old">IRI
Processing
</del>
<ins class="diff-chg">Shallow
Comparison
Algorithm
</ins>
</a>
</li>
<li class="tocline">
<a href="#object-comparison-algorithm" class="tocxref">
<span class="secno">
<ins class="diff-chg">5.11.5
</ins></span><ins class="diff-chg">
Object
Comparison
Algorithm
</ins></a>
</li>
<li class="tocline">
<a href="#deep-comparison-algorithm" class="tocxref">
<span class="secno">
<del class="diff-old">7.
</del>
<ins class="diff-chg">5.11.6
</ins>
</span>
<del class="diff-old">Sequence
</del>
<ins class="diff-chg">Deep
Comparison
Algorithm
</ins>
</a>
</li>
<li class="tocline">
<a href="#node-serialization-algorithm" class="tocxref">
<span class="secno">
<del class="diff-old">8.
</del>
<ins class="diff-chg">5.11.7
</ins>
</span>
<del class="diff-old">Best
Practices
</del>
<ins class="diff-chg">Node
Serialization
Algorithm
</ins>
</a>
</li>
<li class="tocline">
<a href="#combinatorial-serialization-algorithm" class="tocxref">
<span class="secno">
<del class="diff-old">8.1
</del>
<ins class="diff-chg">5.11.8
</ins>
</span>
<del class="diff-old">JavaScript
</del>
<ins class="diff-chg">Combinatorial
Serialization
Algorithm
</ins>
</a>
</li>
<li class="tocline">
<a href="#mapping-serialization-algorithm" class="tocxref">
<span class="secno">
<del class="diff-old">8.2
</del>
<ins class="diff-chg">5.11.9
</ins>
</span>
<del class="diff-old">Schema-less
Databases
</del>
<ins class="diff-chg">Mapping
Serialization
Algorithm
</ins></a></li><li class="tocline"><a href="#label-generation-algorithm" class="tocxref"><span class="secno"><ins class="diff-chg">
5.11.10
</ins></span><ins class="diff-chg">
Label
Generation
Algorithm
</ins>
</a>
</li>
</ul>
</li>
<li class="tocline">
<a href="#data-round-tripping" class="tocxref">
<span class="secno">
<del class="diff-old">9.
</del>
<ins class="diff-chg">5.12
</ins>
</span>
<del class="diff-old">Advanced
Concepts
</del>
<ins class="diff-chg">Data
Round
Tripping
</ins></a></li><li class="tocline"><a href="#rdf-conversion" class="tocxref"><span class="secno"><ins class="diff-chg">
5.13
</ins></span><ins class="diff-chg">
RDF
Conversion
</ins>
</a>
<ul class="toc">
<li class="tocline">
<a href="#overview" class="tocxref">
<span class="secno">
<del class="diff-old">9.1
</del>
<ins class="diff-chg">5.13.1
</ins>
</span>
<del class="diff-old">Vocabulary
Profiles
</del>
<ins class="diff-chg">Overview
</ins></a></li><li class="tocline"><a href="#rdf-conversion-algorithm-terms" class="tocxref"><span class="secno"><ins class="diff-chg">
5.13.2
</ins></span><ins class="diff-chg">
RDF
Conversion
Algorithm
Terms
</ins>
</a>
</li>
<li class="tocline">
<a href="#rdf-conversion-algorithm" class="tocxref">
<span class="secno">
<ins class="diff-new">5.13.3
</ins></span><ins class="diff-new">
RDF
Conversion
Algorithm
</ins></a></li></ul></li></ul></li><li class="tocline"><a href="#experimental-concepts" class="tocxref"><span class="secno"><ins class="diff-new">
6.
</ins></span><ins class="diff-new">
Experimental
Concepts
</ins></a><ul class="toc"><li class="tocline">
<a href="#disjoint-graphs" class="tocxref">
<span class="secno">
<del class="diff-old">9.2
</del>
<ins class="diff-chg">6.1
</ins>
</span>
Disjoint
Graphs
</a>
</li>
<li class="tocline">
<a href="#lists" class="tocxref">
<span class="secno">
<del class="diff-old">9.3
</del>
<ins class="diff-chg">6.2
</ins>
</span>
<del class="diff-old">The
JSON-LD
API
</del>
<ins class="diff-chg">Lists
</ins>
</a>
<ul class="toc">
<li class="tocline">
<a href="#expansion-2" class="tocxref">
<span class="secno">
<del class="diff-old">9.3.1
</del>
<ins class="diff-chg">6.2.1
</ins>
</span>
<del class="diff-old">Methods
</del>
<ins class="diff-chg">Expansion
</ins>
</a>
</li>
<li class="tocline">
<a href="#normalization-2" class="tocxref">
<span class="secno">
<del class="diff-old">9.3.2
</del>
<ins class="diff-chg">6.2.2
</ins>
</span>
<del class="diff-old">Methods
</del>
<ins class="diff-chg">Normalization
</ins>
</a>
</li>
<li class="tocline">
<a href="#rdf-conversion-1" class="tocxref">
<span class="secno">
<del class="diff-old">9.3.3
</del>
<ins class="diff-chg">6.2.3
</ins>
</span>
<del class="diff-old">Methods
</del>
<ins class="diff-chg">RDF
Conversion
</ins>
</a>
</li>
</ul>
</li>
</ul>
</li>
<li class="tocline">
<a href="#markup-examples" class="tocxref">
<span class="secno">
A.
</span>
<del class="diff-old">The
Default
Context
</del>
<ins class="diff-chg">Markup
Examples
</ins></a><ul class="toc"><li class="tocline"><a href="#rdfa" class="tocxref"><span class="secno"><ins class="diff-chg">
A.1
</ins></span><ins class="diff-chg">
RDFa
</ins></a></li><li class="tocline"><a href="#microformats" class="tocxref"><span class="secno"><ins class="diff-chg">
A.2
</ins></span><ins class="diff-chg">
Microformats
</ins></a></li><li class="tocline"><a href="#microdata" class="tocxref"><span class="secno"><ins class="diff-chg">
A.3
</ins></span><ins class="diff-chg">
Microdata
</ins></a></li><li class="tocline"><a href="#mashing-up-vocabularies" class="tocxref"><span class="secno"><ins class="diff-chg">
A.4
</ins></span><ins class="diff-chg">
Mashing
Up
Vocabularies
</ins>
</a>
</li>
<li class="tocline">
<a href="#acknowledgements" class="tocxref">
<span class="secno">
<del class="diff-old">B.
</del>
<ins class="diff-chg">A.5
</ins>
</span>
Acknowledgements
</a>
</li>
</ul>
</li>
<li class="tocline">
<a href="#references" class="tocxref">
<span class="secno">
<del class="diff-old">C.
</del>
<ins class="diff-chg">B.
</ins>
</span>
References
</a>
<ul class="toc">
<li class="tocline">
<a href="#normative-references" class="tocxref">
<span class="secno">
<del class="diff-old">C.1
</del>
<ins class="diff-chg">B.1
</ins>
</span>
Normative
references
</a>
</li>
<li class="tocline">
<a href="#informative-references" class="tocxref">
<span class="secno">
<del class="diff-old">C.2
</del>
<ins class="diff-chg">B.2
</ins>
</span>
Informative
references
</a>
</li>
</ul>
</li>
</ul>
</div>
<div id="introduction" class="section">
<h2>
<span class="secno">
1.
</span>
Introduction
</h2>
<p>
<ins class="diff-new">JSON,
as
specified
in
[
</ins><cite><a class="bibref" rel="biblioentry" href="#bib-RFC4627"><ins class="diff-new">
RFC4627
</ins></a></cite><ins class="diff-new">
],
is
a
simple
language
for
representing
data
on
the
Web.
Linked
Data
is
a
technique
for
describing
content
across
different
documents
or
Web
sites.
Web
resources
are
described
using
</ins><a class="tref internalDFN" title="IRI" href="#dfn-iri"><ins class="diff-new">
IRI
</ins></a><ins class="diff-new">
s,
and
typically
are
dereferencable
entities
that
may
be
used
to
find
more
information,
creating
a
"Web
of
Knowledge".
JSON-LD
is
intended
to
be
a
simple
publishing
method
for
expressing
not
only
Linked
Data
in
JSON,
but
for
adding
semantics
to
existing
JSON.
</ins></p><p>
JSON-LD
is
designed
as
a
light-weight
syntax
that
can
be
used
to
express
Linked
Data.
It
is
primarily
intended
to
be
a
way
to
express
Linked
Data
in
Javascript
and
other
Web-based
programming
environments.
It
is
also
useful
when
building
interoperable
Web
Services
and
when
storing
Linked
Data
in
JSON-based
document
storage
engines.
It
is
practical
and
designed
to
be
as
simple
as
possible,
utilizing
the
large
number
of
JSON
parsers
and
existing
code
that
is
in
use
today.
It
is
designed
to
be
able
to
express
key-value
pairs,
RDF
data,
<ins class="diff-new">RDFa
[
</ins><cite><a class="bibref" rel="biblioentry" href="#bib-RDFA-CORE"><ins class="diff-new">
RDFA-CORE
</ins></a></cite><ins class="diff-new">
]
data,
</ins>
Microformats
<ins class="diff-new">[
</ins><cite><a class="bibref" rel="biblioentry" href="#bib-MICROFORMATS"><ins class="diff-new">
MICROFORMATS
</ins></a></cite><ins class="diff-new">
]
</ins>
data,
and
<del class="diff-old">Microdata.
</del>
<ins class="diff-chg">Microdata
[
</ins><cite><a class="bibref" rel="biblioentry" href="#bib-MICRODATA"><ins class="diff-chg">
MICRODATA
</ins></a></cite><ins class="diff-chg">
].
</ins>
That
is,
it
supports
every
major
Web-based
structured
data
model
in
use
today.
<del class="diff-old">It
</del>
</p>
<p>
<ins class="diff-chg">The
syntax
</ins>
does
not
require
<del class="diff-old">anyone
</del>
<ins class="diff-chg">many
applications
</ins>
to
change
their
JSON,
but
easily
add
meaning
by
adding
context
in
a
way
that
is
<ins class="diff-new">either
in-band
or
</ins>
out-of-band.
The
syntax
is
designed
to
not
disturb
already
deployed
systems
running
on
JSON,
but
provide
a
smooth
migration
path
from
JSON
to
JSON
with
added
semantics.
Finally,
the
format
is
intended
to
be
fast
to
parse,
fast
to
generate,
stream-based
and
document-based
processing
compatible,
and
require
a
very
small
memory
footprint
in
order
to
operate.
</p>
<del class="diff-old">JSON,
as
specified
in
[
RFC4627
],
is
a
simple
language
for
representing
objects
on
the
web.
Linked
Data
is
a
way
of
describing
content
across
different
documents,
or
web
resources.
Web
resources
are
described
using
IRI
s,
and
typically
are
dereferencable
entities
that
may
be
used
to
find
more
information,
creating
a
"web
of
knowledge".
JSON-LD
is
intended
to
be
a
simple
publishing
method
for
expressing
linked
data
in
JSON.
</del>
<div id="how-to-read-this-document" class="section">
<h3>
<span class="secno">
1.1
</span>
How
to
Read
this
Document
</h3>
<p>
This
document
is
a
detailed
specification
for
a
serialization
of
JSON
for
Linked
data.
The
document
is
primarily
intended
for
the
following
audiences:
</p>
<ul>
<li>
Web
developers
that
want
to
understand
the
design
decisions
and
language
syntax
for
JSON-LD.
</li>
<li>
Software
developers
that
want
to
encode
Microformats,
RDFa,
or
Microdata
in
a
way
that
is
cross-language
compatible
via
JSON.
</li>
<li>
Software
developers
that
want
to
<del class="diff-old">write
</del>
<ins class="diff-chg">implement
</ins>
processors
<ins class="diff-new">and
APIs
</ins>
for
JSON-LD.
</li>
</ul>
<p>
To
understand
<ins class="diff-new">the
basics
in
</ins>
this
specification
you
must
first
be
familiar
with
JSON,
which
is
detailed
in
[
<cite>
<a class="bibref" rel="biblioentry" href="#bib-RFC4627">
RFC4627
</a>
</cite>
<ins class="diff-new">].
To
understand
the
API
and
how
it
is
intended
to
operate
in
a
programming
environment,
it
is
useful
to
have
working
knowledge
of
the
JavaScript
programming
language
[
</ins><cite><a class="bibref" rel="biblioentry" href="#bib-ECMA-262"><ins class="diff-new">
ECMA-262
</ins></a></cite>
]
and
<ins class="diff-new">WebIDL
[
</ins><cite><a class="bibref" rel="biblioentry" href="#bib-WEBIDL"><ins class="diff-new">
WEBIDL
</ins></a></cite><ins class="diff-new">
].
To
understand
how
JSON-LD
maps
to
RDF,
it
is
helpful
to
be
familiar
with
the
basic
</ins>
RDF
<del class="diff-old">as
described
in
</del>
<ins class="diff-chg">concepts
</ins>
[
<cite>
<a class="bibref" rel="biblioentry" href="#bib-RDF-CONCEPTS">
RDF-CONCEPTS
</a>
</cite>
].
</p>
<p>
<ins class="diff-new">Examples
may
contain
references
to
existing
vocabularies
and
use
abbreviations
in
CURIEs
and
source
code.
The
following
is
a
list
of
all
vocabularies
and
their
abbreviations,
as
used
in
this
document:
</ins></p><ul><li><ins class="diff-new">
The
</ins><a href="http://purl.org/dc/terms/"><ins class="diff-new">
Dublin
Core
</ins></a><ins class="diff-new">
vocabulary
(abbreviation:
</ins><code><ins class="diff-new">
dc
</ins></code>,<ins class="diff-new">
e.g.,
</ins><code><ins class="diff-new">
dc:title
</ins></code><ins class="diff-new">
)
</ins></li><li><ins class="diff-new">
The
</ins><a href="http://xmlns.com/foaf/0.1/"><ins class="diff-new">
Friend
of
a
Friend
</ins></a><ins class="diff-new">
vocabulary
(abbreviation:
</ins><code><ins class="diff-new">
foaf
</ins></code>,<ins class="diff-new">
e.g.,
</ins><code><ins class="diff-new">
foaf:knows
</ins></code><ins class="diff-new">
)
</ins></li><li><ins class="diff-new">
The
</ins><a href="http://www.w3.org/1999/02/22-rdf-syntax-ns#"><ins class="diff-new">
RDF
</ins></a><ins class="diff-new">
vocabulary
(abbreviation:
</ins><code><ins class="diff-new">
rdf
</ins></code>,<ins class="diff-new">
e.g.,
</ins><code><ins class="diff-new">
rdf:type
</ins></code><ins class="diff-new">
)
</ins></li><li><ins class="diff-new">
The
</ins><a href="http://www.w3.org/2001/XMLSchema#"><ins class="diff-new">
XSD
</ins></a><ins class="diff-new">
vocabulary
(abbreviation:
</ins><code><ins class="diff-new">
xsd
</ins></code>,<ins class="diff-new">
e.g.,
</ins><code><ins class="diff-new">
xsd:integer
</ins></code><ins class="diff-new">
)
</ins></li></ul>
</div>
<div id="contributing" class="section">
<h3>
<span class="secno">
1.2
</span>
Contributing
</h3>
<p>
There
are
a
number
of
ways
that
one
may
participate
in
the
development
of
this
specification:
</p>
<ul>
<li>
<del class="diff-old">All
comments
and
</del>
<ins class="diff-chg">Technical
</ins>
discussion
<del class="diff-old">takes
place
</del>
<ins class="diff-chg">typically
occurs
</ins>
on
the
public
mailing
list:
<a href="http://lists.w3.org/Archives/Public/public-linked-json/">
public-linked-json@w3.org
</a>
</li>
<li>
<a href="http://json-ld.org/minutes/">
<ins class="diff-new">Public
teleconferences
</ins></a><ins class="diff-new">
are
held
on
Tuesdays
at
1500UTC
on
the
second
and
fourth
week
of
each
month.
</ins></li><li>
Specification
bugs
and
issues
should
be
reported
in
the
<a href="https://github.com/json-ld/json-ld.org/issues">
issue
tracker
</a>.
</li>
<li>
<a href="https://github.com/json-ld/json-ld.org/tree/main/spec">
Source
code
</a>
for
the
specification
can
be
found
on
Github.
</li>
<li>
The
<a href="http://webchat.freenode.net/?channels=#json-ld">
#json-ld
</a>
IRC
channel
is
available
for
real-time
discussion
on
irc.freenode.net.
</li>
</ul>
</div>
</div>
<div id="design" class="section">
<h2>
<span class="secno">
2.
</span>
Design
<del class="diff-old">Goals
and
Rationale
</del>
</h2>
<p>
The
following
section
outlines
the
design
goals
and
rationale
behind
the
JSON-LD
markup
language.
</p>
<div id="goals-and-rationale" class="section">
<h3>
<span class="secno">
2.1
</span>
Goals
<ins class="diff-new">and
Rationale
</ins>
</h3>
<p>
A
number
of
design
considerations
were
explored
during
the
creation
of
this
markup
language:
</p>
<dl>
<dt>
Simplicity
</dt>
<dd>
Developers
<del class="diff-old">don't
</del>
need
<del class="diff-old">to
</del>
<ins class="diff-chg">only
</ins>
know
<del class="diff-old">RDF
in
order
</del>
<ins class="diff-chg">JSON
and
three
keywords
</ins>
to
use
the
basic
functionality
<del class="diff-old">provided
by
</del>
<ins class="diff-chg">in
</ins>
JSON-LD.
<ins class="diff-new">No
extra
processors
or
software
libraries
are
necessary
to
use
JSON-LD
in
its
most
basic
form.
The
language
attempts
to
ensure
that
developers
have
an
easy
learning
curve.
</ins>
</dd>
<dt>
Compatibility
</dt>
<dd>
The
JSON-LD
markup
<del class="diff-old">should
</del>
<ins class="diff-chg">must
</ins>
be
100%
compatible
with
JSON.
<ins class="diff-new">This
ensures
that
all
of
the
standard
JSON
libraries
work
seamlessly
with
JSON-LD
documents.
</ins>
</dd>
<dt>
Expressiveness
</dt>
<dd>
<del class="diff-old">All
major
RDF
concepts
</del>
<ins class="diff-chg">The
syntax
</ins>
must
be
<del class="diff-old">expressible
via
the
JSON-LD
syntax.
</del>
<ins class="diff-chg">able
to
express
directed
graphs,
which
have
been
proven
to
be
able
to
simply
express
almost
every
real
world
data
model.
</ins>
</dd>
<dt>
Terseness
</dt>
<dd>
The
JSON-LD
syntax
must
be
very
terse
and
human
<del class="diff-old">readable.
</del>
<ins class="diff-chg">readable,
requiring
as
little
as
possible
from
the
developer.
</ins></dd><dt><ins class="diff-chg">
Pragmatism
</ins></dt><dd><ins class="diff-chg">
Mixing
the
expression
of
pure
Linked
Data
with
data
that
is
not
linked
was
an
approach
that
was
driven
by
pragmatism.
JSON-LD
attempts
to
be
more
practical
than
theoretical
in
its
approach
to
Linked
Data.
</ins>
</dd>
<dt>
Zero
Edits,
most
of
the
time
</dt>
<dd>
JSON-LD
provides
a
mechanism
that
allows
developers
to
specify
context
in
a
way
that
is
out-of-band.
This
allows
organizations
that
have
already
deployed
large
JSON-based
infrastructure
to
add
meaning
to
their
JSON
in
a
way
that
is
not
disruptive
to
their
day-to-day
operations
and
is
transparent
to
their
current
customers.
At
times,
mapping
JSON
to
<del class="diff-old">RDF
</del>
<ins class="diff-chg">a
graph
representation
</ins>
can
become
<del class="diff-old">difficult
-
in
</del>
<ins class="diff-chg">difficult.
In
</ins>
these
instances,
rather
than
having
JSON-LD
support
esoteric
markup,
we
chose
not
to
support
the
use
case
and
support
a
simplified
syntax
instead.
So,
while
<del class="diff-old">we
strive
for
</del>
Zero
<del class="diff-old">Edits,
</del>
<ins class="diff-chg">Edits
was
a
goal,
</ins>
it
was
not
always
possible
without
adding
great
complexity
to
the
language.
</dd>
<dt>
Streaming
</dt>
<dd>
The
format
supports
both
document-based
and
stream-based
processing.
</dd>
</dl>
</div>
<div id="linked-data" class="section">
<h3>
<span class="secno">
2.2
</span>
<del class="diff-old">Map
Terms
</del>
<ins class="diff-chg">Linked
Data
</ins></h3><p><ins class="diff-chg">
The
following
definition
for
</ins><a class="tref internalDFN" title="Linked_Data" href="#dfn-linked_data"><ins class="diff-chg">
Linked
Data
</ins></a><ins class="diff-chg">
is
the
one
that
will
be
used
for
this
specification.
</ins></p><ol><li><dfn title="Linked_Data" id="dfn-linked_data"><ins class="diff-chg">
Linked
Data
</ins></dfn><ins class="diff-chg">
is
a
set
of
documents,
each
containing
a
representation
of
a
linked
data
graph.
</ins></li><li><ins class="diff-chg">
A
</ins><dfn title="linked_data_graph" id="dfn-linked_data_graph"><ins class="diff-chg">
linked
data
graph
</ins></dfn><ins class="diff-chg">
is
a
labeled
directed
graph,
where
nodes
are
</ins><a class="tref internalDFN" title="subject" href="#dfn-subject"><ins class="diff-chg">
subject
</ins></a><ins class="diff-chg">
s
or
</ins><a class="tref internalDFN" title="object" href="#dfn-object"><ins class="diff-chg">
object
</ins></a><ins class="diff-chg">
s,
and
edges
are
properties.
</ins></li><li><ins class="diff-chg">
A
</ins><dfn title="subject" id="dfn-subject"><ins class="diff-chg">
subject
</ins></dfn><ins class="diff-chg">
is
any
node
in
a
</ins><a class="tref internalDFN" title="linked_data_graph" href="#dfn-linked_data_graph"><ins class="diff-chg">
linked
data
graph
</ins></a><ins class="diff-chg">
with
at
least
one
outgoing
edge.
</ins></li><li><ins class="diff-chg">
A
</ins><a class="tref internalDFN" title="subject" href="#dfn-subject"><ins class="diff-chg">
subject
</ins></a><em class="rfc2119" title="should"><ins class="diff-chg">
should
</ins></em><ins class="diff-chg">
be
labeled
with
a
IRI.
</ins></li><li><ins class="diff-chg">
A
</ins><dfn title="property" id="dfn-property"><ins class="diff-chg">
property
</ins></dfn><ins class="diff-chg">
is
an
edge
of
the
</ins><a class="tref internalDFN" title="linked_data_graph" href="#dfn-linked_data_graph"><ins class="diff-chg">
linked
data
graph
</ins></a><ins class="diff-chg">
.
</ins></li><li><ins class="diff-chg">
A
</ins><a class="tref internalDFN" title="property" href="#dfn-property"><ins class="diff-chg">
property
</ins></a><em class="rfc2119" title="must"><ins class="diff-chg">
must
</ins></em><ins class="diff-chg">
be
labeled
with
an
IRI.
</ins></li><li><ins class="diff-chg">
An
</ins><dfn title="object" id="dfn-object"><ins class="diff-chg">
object
</ins></dfn><ins class="diff-chg">
is
a
node
in
a
</ins><a class="tref internalDFN" title="linked_data_graph" href="#dfn-linked_data_graph"><ins class="diff-chg">
linked
data
graph
</ins></a><ins class="diff-chg">
with
at
least
one
incoming
edge.
</ins></li><li><ins class="diff-chg">
An
</ins><a class="tref internalDFN" title="object" href="#dfn-object"><ins class="diff-chg">
object
</ins></a><em class="rfc2119" title="may"><ins class="diff-chg">
may
</ins></em><ins class="diff-chg">
be
labeled
with
an
IRI.
</ins></li><li><ins class="diff-chg">
An
IRI
that
is
a
label
in
a
</ins><a class="tref internalDFN" title="linked_data_graph" href="#dfn-linked_data_graph"><ins class="diff-chg">
linked
data
graph
</ins></a><em class="rfc2119" title="should"><ins class="diff-chg">
should
</ins></em><ins class="diff-chg">
be
dereferencable
</ins>
to
<del class="diff-old">IRIs
</del>
<ins class="diff-chg">a
</ins><a class="tref internalDFN" title="Linked_Data" href="#dfn-linked_data"><ins class="diff-chg">
Linked
Data
</ins></a><ins class="diff-chg">
document
describing
the
labeled
</ins><a class="tref internalDFN" title="subject" href="#dfn-subject"><ins class="diff-chg">
subject
</ins></a>,<a class="tref internalDFN" title="object" href="#dfn-object"><ins class="diff-chg">
object
</ins></a><ins class="diff-chg">
or
</ins><a class="tref internalDFN" title="property" href="#dfn-property"><ins class="diff-chg">
property
</ins></a><ins class="diff-chg">
.
</ins></li><li><ins class="diff-chg">
A
</ins><dfn title="literal" id="dfn-literal"><ins class="diff-chg">
literal
</ins></dfn><ins class="diff-chg">
is
an
</ins><a class="tref internalDFN" title="object" href="#dfn-object"><ins class="diff-chg">
object
</ins></a><ins class="diff-chg">
with
a
label
that
is
not
an
IRI
</ins></li></ol><p><ins class="diff-chg">
Note
that
the
definition
for
</ins><a class="tref internalDFN" title="Linked_Data" href="#dfn-linked_data"><ins class="diff-chg">
Linked
Data
</ins></a><ins class="diff-chg">
above
is
silent
on
the
topic
of
unlabeled
nodes.
Unlabeled
nodes
are
not
considered
</ins><a class="tref internalDFN" title="Linked_Data" href="#dfn-linked_data"><ins class="diff-chg">
Linked
Data
</ins></a>.<ins class="diff-chg">
However,
this
specification
allows
for
the
expression
of
unlabled
nodes,
as
most
graph-based
data
sets
on
the
Web
contain
a
number
of
associated
nodes
that
are
not
named
and
thus
are
not
directly
de-referenceable.
</ins></p></div><div id="linking-data" class="section"><h3><span class="secno"><ins class="diff-chg">
2.3
</ins></span><ins class="diff-chg">
Linking
Data
</ins>
</h3>
<p>
An
Internationalized
Resource
Identifier
(
<dfn title="IRI" id="dfn-iri">
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
</dfn>
<del class="diff-old">)
</del>
<ins class="diff-chg">),
</ins>
as
described
in
[
<cite>
<a class="bibref" rel="biblioentry" href="#bib-RFC3987">
RFC3987
</a>
</cite>
],
is
a
mechanism
for
representing
unique
identifiers
on
the
web.
In
<a class="tref internalDFN" title="Linked_Data" href="#dfn-linked_data">
Linked
<del class="diff-old">Data,
IRIs
(or
URI
references)
are
</del>
<ins class="diff-chg">Data
</ins></a>,<ins class="diff-chg">
an
IRI
is
</ins>
commonly
used
for
<del class="diff-old">describing
entities
and
properties.
</del>
<ins class="diff-chg">expressing
a
</ins><a class="tref internalDFN" title="subject" href="#dfn-subject"><ins class="diff-chg">
subject
</ins></a>,<ins class="diff-chg">
a
</ins><a class="tref internalDFN" title="property" href="#dfn-property"><ins class="diff-chg">
property
</ins></a><ins class="diff-chg">
or
an
</ins><a class="tref internalDFN" title="object" href="#dfn-object"><ins class="diff-chg">
object
</ins></a>.
</p>
<p>
<del class="diff-old">Establishing
</del>
<ins class="diff-chg">JSON-LD
defines
</ins>
a
mechanism
to
map
JSON
values
to
<del class="diff-old">IRIs
will
help
in
the
mapping
of
JSON
objects
to
RDF.
</del>
<ins class="diff-chg">IRIs.
</ins>
This
does
not
mean
that
JSON-LD
<del class="diff-old">must
</del>
<ins class="diff-chg">requires
every
key
or
value
to
</ins>
be
<del class="diff-old">restrictive
in
declaring
a
set
of
terms,
rather,
experimentation
</del>
<ins class="diff-chg">an
IRI,
but
rather
ensures
that
keys
</ins>
and
<del class="diff-old">innovation
should
</del>
<ins class="diff-chg">values
can
</ins>
be
<del class="diff-old">supported
as
part
of
</del>
<ins class="diff-chg">mapped
to
IRIs
if
</ins>
the
<del class="diff-old">core
design
of
JSON-LD.
</del>
<ins class="diff-chg">developer
so
desires
to
transform
their
data
into
Linked
Data.
</ins>
There
<del class="diff-old">are,
however,
</del>
<ins class="diff-chg">are
</ins>
a
<del class="diff-old">number
of
very
small
design
criteria
</del>
<ins class="diff-chg">few
techniques
</ins>
that
can
ensure
that
developers
will
generate
good
<del class="diff-old">RDF
data
that
will
create
value
</del>
<ins class="diff-chg">Linked
Data
</ins>
for
the
<del class="diff-old">greater
semantic
web
community
and
JSON/REST-based
Web
Services
community.
</del>
<ins class="diff-chg">Web.
JSON-LD
formalizes
those
techniques.
</ins>
</p>
<p>
We
will
be
using
the
following
JSON
<del class="diff-old">object
</del>
<ins class="diff-chg">markup
</ins>
as
the
example
for
<ins class="diff-new">the
rest
of
</ins>
this
section:
</p>
<pre class="example">
{
<del class="diff-old">  "a": "Person",
</del>
  "name": "Manu Sporny",
<del class="diff-old">  "homepage": "http://manu.sporny.org/"
</del>
<ins class="diff-chg">  "homepage": "http://manu.sporny.org/",
</ins>
  "avatar": "http://twitter.com/account/profile_image/manusporny"
}
</pre>
</div>
<div id="the-context" class="section">
<h3>
<span class="secno">
<del class="diff-old">2.3
</del>
<ins class="diff-chg">2.4
</ins>
</span>
The
<del class="diff-old">JSON-LD
</del>
Context
</h3>
<p>
<del class="diff-old">A
</del>
<ins class="diff-chg">In
JSON-LD,
a
</ins>
context
is
used
to
allow
developers
to
<del class="diff-old">use
aliases
for
</del>
<ins class="diff-chg">map
</ins><a class="tref internalDFN" title="term" href="#dfn-term"><ins class="diff-chg">
term
</ins></a><ins class="diff-chg">
s
to
</ins>
<a class="tref internalDFN" title="IRI" href="#dfn-iri">
IRI
</a>
s.
<ins class="diff-new">A
</ins><dfn title="term" id="dfn-term"><ins class="diff-new">
term
</ins></dfn><ins class="diff-new">
is
a
short
word
that
</ins><em class="rfc2119" title="may"><ins class="diff-new">
may
</ins></em><ins class="diff-new">
be
expanded
to
an
</ins><a class="tref internalDFN" title="IRI" href="#dfn-iri"><ins class="diff-new">
IRI
</ins></a>.
The
semantic
web,
just
like
the
document-based
web,
uses
IRIs
for
unambiguous
identification.
The
idea
is
that
these
<del class="diff-old">terms
</del>
<a class="tref internalDFN" title="term" href="#dfn-term">
<ins class="diff-chg">term
</ins></a><ins class="diff-chg">
s
</ins>
mean
<del class="diff-old">something,
which
you
will
eventually
want
to
query.
A
context
allows
the
expression
of
a
number
</del>
<ins class="diff-chg">something
that
may
be
</ins>
of
<del class="diff-old">terms
which
map
directly
</del>
<ins class="diff-chg">use
</ins>
to
<del class="diff-old">IRI
s.
</del>
<ins class="diff-chg">other
developers.
</ins>
For
example,
the
term
<code>
name
</code>
may
map
directly
to
the
IRI
<code>
http://xmlns.com/foaf/0.1/name
</code>.
This
allows
JSON-LD
documents
to
be
constructed
using
<ins class="diff-new">the
</ins>
common
JSON
<del class="diff-old">syntax
</del>
<ins class="diff-chg">practice
</ins>
of
<del class="diff-old">using
</del>
simple
name/value
<del class="diff-old">pairs.
</del>
<ins class="diff-chg">pairs
while
ensuring
that
the
data
is
useful
outside
of
the
database
or
page
in
which
it
resides.
</ins>
</p>
<p>
<del class="diff-old">To
reduce
</del>
<ins class="diff-chg">These
Linked
Data
</ins><a class="tref internalDFN" title="term" href="#dfn-term"><ins class="diff-chg">
term
</ins></a><ins class="diff-chg">
s
are
typically
collected
in
a
context
and
then
used
by
adding
a
single
line
to
</ins>
the
<del class="diff-old">number
of
different
</del>
<ins class="diff-chg">JSON
markup
above:
</ins></p><pre class="example"><ins class="diff-chg">
{
</ins>  <span class="diff">"@context": "http://example.org/json-ld-contexts/person",</span><ins class="diff-chg">
  "name": "Manu Sporny",
  "homepage": "http://manu.sporny.org/",
  "avatar": "http://twitter.com/account/profile_image/manusporny"
}
</ins></pre><p><ins class="diff-chg">
The
addition
above
transforms
the
previous
JSON
document
into
a
JSON
document
with
added
semantics
because
the
</ins><code><ins class="diff-chg">
@context
</ins></code><ins class="diff-chg">
specifies
how
the
</ins><strong><ins class="diff-chg">
name
</ins></strong>,<strong><ins class="diff-chg">
homepage
</ins></strong>,<ins class="diff-chg">
and
</ins><strong><ins class="diff-chg">
avatar
</ins></strong>
terms
<del class="diff-old">that
must
be
defined,
JSON-LD
also
</del>
<ins class="diff-chg">map
to
IRIs.
Mapping
those
keys
to
IRIs
gives
the
data
global
context.
If
two
developers
use
the
same
IRI
to
describe
a
property,
they
are
more
than
likely
expressing
the
same
concept.
This
</ins>
allows
<del class="diff-old">terms
</del>
<ins class="diff-chg">both
developers
</ins>
to
<del class="diff-old">be
used
</del>
<ins class="diff-chg">re-use
each
others
data
without
having
</ins>
to
<del class="diff-old">expand
Compact
URIs
(
CURIE
).
</del>
<ins class="diff-chg">agree
to
how
their
data
will
inter-operate
on
a
site-by-site
basis.
</ins></p><p>
The
semantic
web
<del class="diff-old">specifies
this
via
</del>
<ins class="diff-chg">uses
a
special
type
of
document
called
a
</ins>
<em>
<ins class="diff-new">Web
</ins>
Vocabulary
<del class="diff-old">Documents
,
in
which
</del>
</em>
<ins class="diff-chg">to
define
</ins><a class="tref internalDFN" title="term" href="#dfn-term"><ins class="diff-chg">
term
</ins></a><ins class="diff-chg">
s.
A
context
is
</ins>
a
<ins class="diff-new">type
of
Web
vocabulary.
Typically,
these
Web
Vocabulary
documents
have
</ins><a class="tref internalDFN" title="prefix" href="#dfn-prefix">
prefix
<del class="diff-old">is
</del>
</a>
<ins class="diff-chg">es
</ins>
associated
with
<del class="diff-old">a
document,
</del>
<ins class="diff-chg">them
</ins>
and
<ins class="diff-new">contain
</ins>
a
<del class="diff-old">suffix
</del>
<ins class="diff-chg">number
of
</ins><a class="tref internalDFN" title="term" href="#dfn-term"><ins class="diff-chg">
term
</ins></a><ins class="diff-chg">
declarations.
A
</ins><dfn title="prefix" id="dfn-prefix"><ins class="diff-chg">
prefix
</ins></dfn>,<ins class="diff-chg">
like
a
</ins><a class="tref internalDFN" title="term" href="#dfn-term"><ins class="diff-chg">
term
</ins></a>,
is
<del class="diff-old">used
</del>
<ins class="diff-chg">a
short
word
that
expands
</ins>
to
<del class="diff-old">create
an
IRI
based
on
this
</del>
<ins class="diff-chg">a
Web
Vocabulary
IRI.
</ins><a class="tref internalDFN" title="Prefix" href="#dfn-prefix"><ins class="diff-chg">
Prefix
</ins></a><ins class="diff-chg">
es
are
helpful
when
a
developer
wants
to
mix
multiple
vocabularies
together
in
a
context,
but
does
not
want
to
go
to
the
trouble
of
defining
every
single
term
in
every
single
</ins>
vocabulary.
<ins class="diff-new">Some
Web
Vocabularies
may
have
10-20
terms
defined.
If
a
developer
wants
to
use
3-4
different
vocabularies,
the
number
of
terms
that
would
have
to
be
declared
in
a
single
context
would
become
quite
large.
To
reduce
the
number
of
different
terms
that
must
be
defined,
JSON-LD
also
allows
prefixes
to
be
used
to
compact
IRIs.
</ins></p><p></p><p>
For
example,
the
IRI
<code>
http://xmlns.com/foaf/0.1/
</code>
specifies
a
<ins class="diff-new">Web
</ins>
Vocabulary
<del class="diff-old">Document,
and
</del>
<ins class="diff-chg">which
may
be
represented
using
the
</ins><code><ins class="diff-chg">
foaf
</ins></code><a class="tref internalDFN" title="prefix" href="#dfn-prefix"><ins class="diff-chg">
prefix
</ins></a>.<ins class="diff-chg">
The
</ins><code><ins class="diff-chg">
foaf
</ins></code><ins class="diff-chg">
Web
Vocabulary
contains
a
term
called
</ins><strong><ins class="diff-chg">
name
</ins></strong>.<ins class="diff-chg">
If
you
join
the
</ins><code><ins class="diff-chg">
foaf
</ins></code><a class="tref internalDFN" title="prefix" href="#dfn-prefix"><ins class="diff-chg">
prefix
</ins></a><ins class="diff-chg">
with
the
</ins>
<strong>
name
</strong>
<del class="diff-old">is
</del>
<ins class="diff-chg">suffix,
you
can
build
</ins>
a
<del class="diff-old">term
in
</del>
<ins class="diff-chg">compact
IRI
</ins>
that
<del class="diff-old">vocabulary.
Join
the
two
items
together
and
you
have
</del>
<ins class="diff-chg">will
expand
out
into
</ins>
an
<del class="diff-old">unambiguous
identifier
</del>
<ins class="diff-chg">absolute
IRI
</ins>
for
<del class="diff-old">a
</del>
<ins class="diff-chg">the
</ins><code><ins class="diff-chg">
http://xmlns.com/foaf/0.1/name
</ins></code>
vocabulary
term.
<del class="diff-old">The
Compact
URI
Expression,
</del>
<ins class="diff-chg">That
is,
the
compact
IRI,
</ins>
or
short-form,
is
<code>
foaf:name
</code>
and
the
expanded-form
is
<code>
http://xmlns.com/foaf/0.1/name
</code>.
This
vocabulary
term
<del class="diff-old">identifies
the
given
name
for
something,
for
example
-
</del>
<ins class="diff-chg">is
used
to
specify
</ins>
a
person's
name.
</p>
<p>
Developers,
and
machines,
<del class="diff-old">would
be
</del>
<ins class="diff-chg">are
</ins>
able
to
use
this
IRI
(plugging
it
directly
into
a
web
browser,
for
instance)
to
go
to
the
term
and
get
a
definition
of
what
the
term
means.
Much
like
we
can
use
WordNet
today
to
see
the
<a href="http://wordnetweb.princeton.edu/perl/webwn?s=definition">
definition
</a>
of
words
in
the
English
language.
<del class="diff-old">Machines
</del>
<ins class="diff-chg">Developers
and
machines
</ins>
need
the
same
sort
of
dictionary
of
<del class="diff-old">terms,
and
URIs
</del>
<ins class="diff-chg">terms.
IRIs
</ins>
provide
a
way
to
ensure
that
these
terms
are
unambiguous.
</p>
<p>
The
context
provides
a
collection
of
vocabulary
<del class="diff-old">terms
</del>
<a class="tref internalDFN" title="term" href="#dfn-term">
<ins class="diff-chg">term
</ins></a><ins class="diff-chg">
s
and
</ins><a class="tref internalDFN" title="prefix" href="#dfn-prefix"><ins class="diff-chg">
prefix
</ins></a><ins class="diff-chg">
es
</ins>
that
can
be
used
<del class="diff-old">for
a
</del>
<ins class="diff-chg">to
expand
</ins>
JSON
<del class="diff-old">object.
</del>
<ins class="diff-chg">keys
and
values
into
</ins><a class="tref internalDFN" title="IRI" href="#dfn-iri"><ins class="diff-chg">
IRI
</ins></a><ins class="diff-chg">
s.
</ins>
</p>
<div id="inside-a-context" class="section">
<h4>
<span class="secno">
<del class="diff-old">2.4
</del>
<ins class="diff-chg">2.4.1
</ins>
</span>
<del class="diff-old">Unambiguous
Identifiers
for
JSON
If
a
set
of
terms,
like
Person
,
name
,
and
homepage
,
are
defined
in
</del>
<ins class="diff-chg">Inside
</ins>
a
<del class="diff-old">context,
and
that
context
is
used
to
resolve
</del>
<ins class="diff-chg">Context
</ins></h4><p><ins class="diff-chg">
In
</ins>
the
<del class="diff-old">names
in
JSON
objects,
machines
could
automatically
expand
</del>
<ins class="diff-chg">previous
section,
</ins>
the
<del class="diff-old">terms
</del>
<ins class="diff-chg">developer
used
the
</ins><code><ins class="diff-chg">
@context
</ins></code><ins class="diff-chg">
keyword
</ins>
to
<ins class="diff-new">pull
in
an
external
context.
That
context
document,
if
de-referenced,
would
look
</ins>
something
<del class="diff-old">meaningful
and
unambiguous,
</del>
like
this:
</p>
<pre class="example">
{
<del class="diff-old">  "",
  "": "Manu Sporny",
  "": "http://manu.sporny.org"
  "": "http://twitter.com/account/profile_image/manusporny"
</del>
<ins class="diff-chg">    "name": "http://xmlns.com/foaf/0.1/name",
    "homepage": "http://xmlns.com/foaf/0.1/homepage",
    "avatar": "http://xmlns.com/foaf/0.1/avatar"
</ins>
}
</pre>
<p>
<del class="diff-old">Doing
this
would
mean
that
JSON
would
start
to
become
unambiguously
machine-readable,
play
well
with
the
semantic
web,
and
basic
markup
wouldn't
be
that
much
more
complex
than
basic
JSON
markup.
</del>
A
<del class="diff-old">win,
all
around.
2.5
Mashing
Up
Vocabularies
Developers
would
also
benefit
by
allowing
other
vocabularies
to
be
used
automatically
with
their
JSON
API.
There
are
over
200
Vocabulary
Documents
that
are
available
for
use
on
the
Web
today.
Some
of
these
vocabularies
are:
RDF
-
for
describing
information
about
objects
on
the
semantic
web.
RDFS
-
for
expressing
things
like
labels
and
comments.
XSD
-
for
specifying
basic
types
like
strings,
integers,
dates
and
times.
Dublin
Core
-
for
describing
creative
works.
FOAF
-
for
describing
social
networks.
Calendar
-
for
specifying
events.
SIOC
-
for
describing
discussions
on
blogs
and
websites.
CCrel
-
for
describing
Creative
Commons
and
other
types
of
licenses.
GEO
-
for
describing
geographic
location.
VCard
-
for
describing
organizations
and
people.
DOAP
-
for
describing
projects.
Since
these
vocabularies
are
very
popular,
they
are
pre-defined
in
something
called
the
default
</del>
<ins class="diff-chg">JSON-LD
</ins>
context
<del class="diff-old">,
which
</del>
<ins class="diff-chg">document
</ins>
is
a
<del class="diff-old">set
of
vocabulary
prefixes
that
are
pre-loaded
in
all
JSON-LD
processors.
The
contents
of
the
default
context
</del>
<ins class="diff-chg">simple
mapping
from
</ins><a class="tref internalDFN" title="term" href="#dfn-term"><ins class="diff-chg">
term
</ins>
</a>
<del class="diff-old">are
provided
later
in
this
document.
Using
the
default
context
</del>
<ins class="diff-chg">s
and
</ins><a class="tref internalDFN" title="prefix" href="#dfn-prefix"><ins class="diff-chg">
prefix
</ins>
</a>
<del class="diff-old">allows
developers
</del>
<ins class="diff-chg">es
</ins>
to
<del class="diff-old">express
data
unambiguously,
like
so:
{
  "",
  "": "Manu Sporny",
  "": "http://manu.sporny.org/",
  "": "http://twitter.com/account/profile_image/manusporny"
}
Developers
can
</del>
<ins class="diff-chg">expanded
values
such
as
IRIs
or
keywords.
Contexts
may
</ins>
also
<del class="diff-old">specify
their
own
Vocabulary
documents
by
modifying
the
active
context
</del>
<ins class="diff-chg">contain
datatype
information
for
certain
</ins><a class="tref internalDFN" title="term" href="#dfn-term"><ins class="diff-chg">
term
</ins>
</a>
<del class="diff-old">in-line
using
the
@context
keyword,
like
so:
{
  ,
  "a": "foaf:Person",
  "foaf:name": "Manu Sporny",
  "foaf:homepage": "http://manu.sporny.org/",
  "sioc:avatar": "http://twitter.com/account/profile_image/manusporny",
  "myvocab:personality": "friendly"
}
The
@context
keyword
is
used
to
change
how
the
JSON-LD
processor
evaluates
key-value
pairs.
In
this
case,
it
was
used
to
map
one
string
('myvocab')
to
another
string,
which
is
interpreted
</del>
<ins class="diff-chg">s
</ins>
as
<del class="diff-old">a
IRI
.
In
the
example
above,
the
myvocab
string
is
replaced
with
"
http://example.org/myvocab#
"
when
it
is
detected.
In
</del>
<ins class="diff-chg">well
as
other
processing
instructions
for
</ins>
the
<del class="diff-old">example
above,
"
myvocab:personality
"
would
expand
to
"
http://example.org/myvocab#personality
".
</del>
<ins class="diff-chg">JSON-LD
processor.
</ins>
</p>
<p>
<ins class="diff-new">Contexts
may
be
specified
in-line.
</ins>
This
<del class="diff-old">mechanism
is
a
short-hand
for
RDF,
called
</del>
<ins class="diff-chg">ensures
that
JSON-LD
documents
can
be
processed
when
</ins>
a
<del class="diff-old">CURIE,
and
provides
developers
an
unambiguous
way
to
map
any
JSON
value
</del>
<ins class="diff-chg">JSON-LD
processor
does
not
have
access
</ins>
to
<del class="diff-old">RDF.
</del>
<ins class="diff-chg">the
Web.
</ins>
</p>
<del class="diff-old">2.6
An
Example
of
a
Context
</del>
<p>
JSON-LD
strives
to
ensure
that
developers
don't
have
to
change
the
JSON
that
is
going
into
and
being
returned
from
their
Web
applications.
<ins class="diff-new">This
means
that
developers
can
also
specify
a
context
for
JSON
data
in
an
out-of-band
fashion
via
the
API.
The
API
is
described
later
in
this
document.
</ins>
A
JSON-LD
aware
Web
Service
<em class="rfc2119" title="may">
may
</em>
<ins class="diff-new">also
</ins>
define
a
<del class="diff-old">known
context.
For
example,
the
following
default
</del>
context
<del class="diff-old">could
apply
to
all
incoming
Web
Service
calls
previously
accepting
only
JSON
data:
{
  "@context": 
  {
    "@vocab": "http://example.org/default-vocab#",
    "@base": "http://example.org/baseurl/",
    "xsd": "http://www.w3.org/2001/XMLSchema#",
    "dc": "http://purl.org/dc/terms/",
    "foaf": "http://xmlns.com/foaf/0.1/",
    "sioc": "http://rdfs.org/sioc/ns#",
    "cc": "http://creativecommons.org/ns#",
    "geo": "http://www.w3.org/2003/01/geo/wgs84_pos#",
    "vcard": "http://www.w3.org/2006/vcard/ns#",
    "cal": "http://www.w3.org/2002/12/cal/ical#",
    "doap": "http://usefulinc.com/ns/doap#",
    "Person": "http://xmlns.com/foaf/0.1/Person",
    "name": "http://xmlns.com/foaf/0.1/name",
    "homepage": "http://xmlns.com/foaf/0.1/homepage"
    "@coerce": 
    {
      "xsd:anyURI": ["rdf:type", "rdf:rest", "foaf:homepage", "foaf:member"],
      "xsd:integer": "foaf:age"
    }
  }
}
The
@vocab
string
is
a
special
keyword
that
states
</del>
that
<del class="diff-old">any
term
that
doesn't
resolve
to
a
term
or
a
prefix
should
</del>
<ins class="diff-chg">will
</ins>
be
<del class="diff-old">appended
</del>
<ins class="diff-chg">pre-loaded
for
all
calls
</ins>
to
the
<del class="diff-old">@vocab
IRI.
</del>
<ins class="diff-chg">service.
</ins>
This
<del class="diff-old">is
done
to
ensure
that
terms
can
be
transformed
to
an
IRI
at
all
times.
The
@base
string
is
a
special
keyword
that
states
</del>
<ins class="diff-chg">allows
services
</ins>
that
<del class="diff-old">any
relative
IRI
must
be
appended
to
the
string
specified
by
@base
.
The
@coerce
keyword
is
used
to
specify
type
coercion
rules
for
the
data.
For
each
key
in
the
map,
the
key
is
the
type
to
be
coerced
to
</del>
<ins class="diff-chg">have
previously
been
publishing
</ins>
and
<del class="diff-old">the
value
is
the
vocabulary
term
</del>
<ins class="diff-chg">receiving
JSON
data
</ins>
to
<del class="diff-old">be
coerced.
Type
coercion
for
the
key
xsd:anyURI
asserts
that
all
vocabulary
terms
listed
should
undergo
coercion
</del>
<ins class="diff-chg">accept
JSON-LD
data
without
requiring
client
software
</ins>
to
<del class="diff-old">an
IRI,
including
@base
processing
for
relative
IRIs
and
CURIE
processing
for
compact
URI
Expressions
such
as
foaf:homepage
.
</del>
<ins class="diff-chg">change.
</ins>
</p>
</div>
</div>
<div id="from-json-to-json-ld" class="section">
<h3>
<span class="secno">
<del class="diff-old">3.
</del>
<ins class="diff-chg">2.5
</ins>
</span>
<del class="diff-old">Markup
Examples
The
JSON-LD
markup
examples
below
demonstrate
how
JSON-LD
can
be
used
</del>
<ins class="diff-chg">From
JSON
</ins>
to
<del class="diff-old">express
semantic
data
marked
up
in
other
languages
such
as
RDFa,
Microformats,
and
Microdata.
These
sections
are
merely
provided
as
proof
that
</del>
JSON-LD
<del class="diff-old">is
very
flexible
in
what
it
can
express
across
different
Linked
Data
approaches.
3.1
RDFa
</del>
</h3>
<p>
<del class="diff-old">The
following
example
describes
three
people
with
their
respective
names
</del>
<ins class="diff-chg">If
a
set
of
terms
such
as,
</ins><strong><ins class="diff-chg">
name
</ins></strong>,<strong><ins class="diff-chg">
homepage
</ins></strong>,
and
<del class="diff-old">homepages.
&lt;div &gt;
   &lt;ul&gt;
      &lt;li &gt;
        &lt;a &gt;Bob&lt;/a&gt;
      &lt;/li&gt;
      &lt;li &gt;
        &lt;a &gt;Eve&lt;/a&gt;
      &lt;/li&gt;
      &lt;li &gt;
        &lt;a &gt;Manu&lt;/a&gt;
      &lt;/li&gt;
   &lt;/ul&gt;
&lt;/div&gt;
An
example
JSON-LD
implementation
is
described
below,
however,
there
</del>
<strong>
<ins class="diff-chg">avatar
</ins></strong>,
are
<del class="diff-old">other
ways
to
mark-up
this
information
such
</del>
<ins class="diff-chg">defined
in
a
context,
and
</ins>
that
<del class="diff-old">the
</del>
context
is
<del class="diff-old">not
repeated.
[
 {
   "@": "_:bnode1",
   "a": "foaf:Person",
   "foaf:homepage": "http://example.com/bob/",
   "foaf:name": "Bob"
 },
 {
   "@": "_:bnode2",
   "a": "foaf:Person",
   "foaf:homepage": "http://example.com/eve/",
   "foaf:name": "Eve"
 },
 {
   "@": "_:bnode3",
   "a": "foaf:Person",
   "foaf:homepage": "http://example.com/manu/",
   "foaf:name": "Manu"
 }
]
3.2
Microformats
The
following
example
uses
a
simple
Microformats
hCard
example
</del>
<ins class="diff-chg">used
</ins>
to
<del class="diff-old">express
how
</del>
<ins class="diff-chg">resolve
</ins>
the
<del class="diff-old">Microformat
is
represented
</del>
<ins class="diff-chg">names
</ins>
in
<del class="diff-old">JSON-LD.
&lt;div class="vcard"&gt;
 &lt;a class="url fn" href="http://tantek.com/"&gt;Tantek Çelik&lt;/a&gt;
&lt;/div&gt;
The
representation
of
the
hCard
expresses
</del>
<ins class="diff-chg">JSON
objects,
machines
are
able
to
automatically
expand
</ins>
the
<del class="diff-old">Microformat
</del>
terms
<del class="diff-old">in
the
context
and
uses
them
directly
for
the
url
and
fn
properties.
Also
note
that
the
Microformat
</del>
to
<del class="diff-old">JSON-LD
processor
has
generated
the
proper
URL
type
for
http://tantek.com
.
</del>
<ins class="diff-chg">something
meaningful
and
unambiguous,
like
this:
</ins>
</p>
<pre class="example">
{
<del class="diff-old">  "@context": 
  {
    "vcard": "http://microformats.org/profile/hcard#vcard",
    "url": "http://microformats.org/profile/hcard#url",
    "fn": "http://microformats.org/profile/hcard#fn",
    "@coerce": { "xsd:anyURI": "url" }
  },
  "@": "_:bnode1",
  "a": "vcard",
  "url": "http://tantek.com/",
  "fn": "Tantek Çelik"
</del>
<ins class="diff-chg">  "<span class="diff">http://xmlns.com/foaf/0.1/name</span>": "Manu Sporny",
  "<span class="diff">http://xmlns.com/foaf/0.1/homepage</span>": "http://manu.sporny.org"
  "<span class="diff">http://rdfs.org/sioc/ns#avatar</span>": "http://twitter.com/account/profile_image/manusporny"
</ins>
}
</pre>
<del class="diff-old">3.3
Microdata
The
Microdata
example
below
expresses
book
information
as
a
Microdata
Work
item.
&lt;dl itemscope
    itemtype="http://purl.org/vocab/frbr/core#Work"
    itemid="http://purl.oreilly.com/works/45U8QJGZSQKDH8N"&gt;
 &lt;dt&gt;Title&lt;/dt&gt;
 &lt;dd&gt;&lt;cite itemprop="http://purl.org/dc/terms/title"&gt;Just a Geek&lt;/cite&gt;&lt;/dd&gt;
 &lt;dt&gt;By&lt;/dt&gt;
 &lt;dd&gt;&lt;span itemprop="http://purl.org/dc/terms/creator"&gt;Wil Wheaton&lt;/span&gt;&lt;/dd&gt;
 &lt;dt&gt;Format&lt;/dt&gt;
 &lt;dd itemprop="http://purl.org/vocab/frbr/core#realization"
     itemscope
     itemtype="http://purl.org/vocab/frbr/core#Expression"
     itemid="http://purl.oreilly.com/products/9780596007683.BOOK"&gt;
  &lt;link itemprop="http://purl.org/dc/terms/type" href="http://purl.oreilly.com/product-types/BOOK"&gt;
  Print
 &lt;/dd&gt;
 &lt;dd itemprop="http://purl.org/vocab/frbr/core#realization"
     itemscope
     itemtype="http://purl.org/vocab/frbr/core#Expression"
     itemid="http://purl.oreilly.com/products/9780596802189.EBOOK"&gt;
  &lt;link itemprop="http://purl.org/dc/terms/type" href="http://purl.oreilly.com/product-types/EBOOK"&gt;
  Ebook
 &lt;/dd&gt;
&lt;/dl&gt;
</del>
<p>
<del class="diff-old">Note
that
the
JSON-LD
representation
of
the
Microdata
information
stays
true
to
the
desires
of
the
Microdata
community
</del>
<ins class="diff-chg">Doing
this
allows
JSON
</ins>
to
<del class="diff-old">avoid
contexts
and
instead
refer
</del>
<ins class="diff-chg">be
unambiguously
machine-readable
without
requiring
developers
that
use
JSON
</ins>
to
<del class="diff-old">items
by
</del>
<ins class="diff-chg">drastically
change
</ins>
their
<del class="diff-old">full
IRI.
</del>
<ins class="diff-chg">workflow.
</ins>
</p>
<del class="diff-old">[
  {
    "@": "http://purl.oreilly.com/works/45U8QJGZSQKDH8N",
    "a": "http://purl.org/vocab/frbr/core#Work",
    "http://purl.org/dc/terms/title": "Just a Geek",
    "http://purl.org/dc/terms/creator": "Whil Wheaton",
    "http://purl.org/vocab/frbr/core#realization": 
      ["http://purl.oreilly.com/products/9780596007683.BOOK", "http://purl.oreilly.com/products/9780596802189.EBOOK"]
  },
  {
    "@": "http://purl.oreilly.com/products/9780596007683.BOOK",
    "a": "http://purl.org/vocab/frbr/core#Expression",
    "http://purl.org/dc/terms/type": "http://purl.oreilly.com/product-types/BOOK"
  },
  {
    "@": "http://purl.oreilly.com/products/9780596802189.EBOOK",
    "a": "http://purl.org/vocab/frbr/core#Expression",
    "http://purl.org/dc/terms/type": "http://purl.oreilly.com/product-types/EBOOK"
  }
]
</del>
</div>
</div>
<div id="basic-concepts" class="section">
<h2>
<span class="secno">
<del class="diff-old">4.
</del>
<ins class="diff-chg">3.
</ins>
</span>
<del class="diff-old">Markup
of
RDF
</del>
<ins class="diff-chg">Basic
</ins>
Concepts
</h2>
<p>
JSON-LD
is
designed
to
ensure
that
<del class="diff-old">most
</del>
Linked
Data
concepts
can
be
marked
up
in
a
way
that
is
simple
to
understand
and
author
by
Web
developers.
In
many
cases,
<del class="diff-old">Javascript
objects
</del>
<ins class="diff-chg">regular
JSON
markup
</ins>
can
become
Linked
Data
with
the
simple
addition
of
a
context.
<del class="diff-old">Since
RDF
is
also
an
important
sub-community
of
the
Linked
Data
movement,
it
is
important
that
all
RDF
concepts
</del>
<ins class="diff-chg">As
more
JSON-LD
features
</ins>
are
<del class="diff-old">well-represented
in
this
specification.
This
section
details
how
each
RDF
concept
can
be
expressed
in
JSON-LD.
</del>
<ins class="diff-chg">used,
more
semantics
are
added
to
the
JSON
markup.
</ins>
</p>
<div id="iris" class="section">
<h3>
<span class="secno">
<del class="diff-old">4.1
</del>
<ins class="diff-chg">3.1
</ins>
</span>
IRIs
</h3>
<p>
Expressing
IRIs
are
fundamental
to
Linked
Data
as
that
is
how
most
<del class="diff-old">subjects
</del>
<a class="tref internalDFN" title="subject" href="#dfn-subject">
<ins class="diff-chg">subject
</ins></a><ins class="diff-chg">
s
</ins>
and
many
<del class="diff-old">objects
</del>
<a class="tref internalDFN" title="object" href="#dfn-object">
<ins class="diff-chg">object
</ins></a>
are
<del class="diff-old">identified.
</del>
<ins class="diff-chg">named.
</ins>
IRIs
can
be
expressed
in
a
variety
of
different
ways
in
JSON-LD.
</p>
<ol>
<li>
In
general,
<del class="diff-old">an
IRI
is
generated
if
it
is
</del>
<a class="tref internalDFN" title="term" href="#dfn-term">
<ins class="diff-chg">term
</ins></a><ins class="diff-chg">
s
</ins>
in
the
key
position
in
an
associative
<del class="diff-old">array.
</del>
<ins class="diff-chg">array
that
have
a
mapping
to
an
IRI
or
another
key
in
the
context
are
expanded
to
an
IRI
by
JSON-LD
processors.
</ins>
There
are
special
rules
for
processing
keys
in
<code>
@context
</code>
and
when
dealing
with
keys
that
start
with
the
<code>
<del class="diff-old">@
</del>
<ins class="diff-chg">@subject
</ins>
</code>
character.
</li>
<li>
An
IRI
is
generated
for
the
value
specified
using
<code>
<del class="diff-old">@
</del>
<ins class="diff-chg">@subject
</ins>
</code>,
if
it
is
a
string.
</li>
<li>
An
IRI
is
generated
for
the
value
specified
using
<code>
<del class="diff-old">a
</del>
<ins class="diff-chg">@type
</ins>
</code>.
</li>
<li>
An
IRI
is
generated
for
the
value
specified
using
the
<code>
@iri
</code>
keyword.
</li>
<li>
An
IRI
is
generated
when
there
are
<code>
@coerce
</code>
rules
in
effect
for
<del class="diff-old">xsd:anyURI
for
</del>
a
<del class="diff-old">particular
vocabulary
term.
</del>
<ins class="diff-chg">key
named
</ins><code><ins class="diff-chg">
@iri
</ins></code>.
</li>
</ol>
<p>
<del class="diff-old">An
example
of
IRI
generation
for
a
</del>
<ins class="diff-chg">IRIs
can
be
expressed
directly
in
the
</ins>
key
<del class="diff-old">outside
of
a
@context
:
</del>
<ins class="diff-chg">position
like
so:
</ins>
</p>
<pre class="example">
{
...
  "<span class="diff">http://xmlns.com/foaf/0.1/name</span>": "Manu Sporny",
...
}
</pre>
<p>
In
the
example
above,
the
key
<code>
http://xmlns.com/foaf/0.1/name
</code>
is
interpreted
as
an
IRI,
as
opposed
to
being
interpreted
as
a
string..
</p>
<p>
Term
expansion
occurs
for
IRIs
if
a
term
is
defined
within
the
<a class="tref internalDFN" title="active_context" href="#dfn-active_context">
active
context
</a>:
</p>
<pre class="example">
{
  "<span class="diff">@context</span>": {"<span class="diff">name</span>": "<span class="diff">http://xmlns.com/foaf/0.1/name</span>"},
...
  "<span class="diff">name</span>": "Manu Sporny",
...
}
</pre>
<p>
<del class="diff-old">CURIE
expansion
also
occurs
for
keys
</del>
<a class="tref internalDFN" title="Prefix" href="#dfn-prefix">
<ins class="diff-chg">Prefix
</ins></a><ins class="diff-chg">
es
are
expanded
when
used
</ins>
in
<del class="diff-old">JSON-LD:
</del>
<ins class="diff-chg">keys:
</ins>
</p>
<pre class="example">
{
<ins class="diff-new">  "<span class="diff">@context</span>": {"<span class="diff">foaf</span>": "<span class="diff">http://xmlns.com/foaf/0.1/</span>"},
</ins>
...
  "<span class="diff">foaf:name</span>": "Manu Sporny",
...
}
</pre>
<p>
<code>
foaf:name
</code>
above
will
automatically
expand
out
to
the
IRI
<code>
http://xmlns.com/foaf/0.1/name
</code>.
</p>
<p>
An
IRI
is
generated
when
a
value
is
associated
with
a
key
using
the
<code>
@iri
</code>
keyword:
</p>
<pre class="example">
{
...
  "foaf:homepage": { "<span class="diff">@iri</span>": "http://manu.sporny.org" }
...
}
</pre>
<p>
If
type
coercion
rules
are
specified
in
the
<code>
@context
</code>
for
a
particular
vocabulary
term,
an
IRI
is
generated:
</p>
<pre class="example">
{<span class="diff">
  "@context": 
<del class="diff-old">  { 
</del>
<ins class="diff-chg">  {
    ...
</ins>
    "@coerce": 
    {
<del class="diff-old">      "xsd:anyURI": "foaf:homepage"
    } 
</del>
<ins class="diff-chg">      "@iri": "foaf:homepage"
    }
</ins>
  }</span>
...
<del class="diff-old">  "foaf:homepage": "http://manu.sporny.org",
</del>
<ins class="diff-chg">  "foaf:homepage": "http://manu.sporny.org/",
</ins>
...
}
</pre>
<p>
<ins class="diff-new">Even
though
the
value
</ins><code><ins class="diff-new">
http://manu.sporny.org/
</ins></code><ins class="diff-new">
is
a
string,
the
type
coercion
rules
will
transform
the
value
into
an
IRI
when
processed
by
a
JSON-LD
Processor
</ins></p>
</div>
<div id="identifying-the-subject" class="section">
<h3>
<span class="secno">
<del class="diff-old">4.2
</del>
<ins class="diff-chg">3.2
</ins>
</span>
Identifying
the
Subject
</h3>
<p>
A
subject
is
declared
using
the
<code>
<del class="diff-old">@
</del>
<ins class="diff-chg">@subject
</ins>
</code>
key.
The
subject
is
the
first
piece
of
information
needed
by
the
JSON-LD
processor
in
order
to
create
the
(subject,
property,
object)
tuple,
also
known
as
a
triple.
</p>
<pre class="example">
{
...
<del class="diff-old">  "",
</del>
<ins class="diff-chg">  "<span class="diff">@subject</span>": "<span class="diff">http://example.org/people#joebob</span>",
</ins>
...
}
</pre>
<p>
The
example
above
would
set
the
subject
to
the
IRI
<code>
http://example.org/people#joebob
</code>.
</p>
</div>
<div id="specifying-the-type" class="section">
<h3>
<span class="secno">
<del class="diff-old">4.3
</del>
<ins class="diff-chg">3.3
</ins>
</span>
Specifying
the
Type
</h3>
<p>
The
type
of
a
particular
subject
can
be
specified
using
the
<code>
<del class="diff-old">a
</del>
<ins class="diff-chg">@type
</ins>
</code>
key.
Specifying
the
type
in
this
way
will
generate
a
triple
of
the
form
(subject,
type,
type-url).
</p>
<pre class="example">
{
...
<del class="diff-old">  "@": "http://example.org/people#joebob",
  "",
</del>
<ins class="diff-chg">  "@subject": "http://example.org/people#joebob",
  "<span class="diff">@type</span>": "<span class="diff">http://xmlns.com/foaf/0.1/Person</span>",
</ins>
...
}
</pre>
<p>
The
example
above
would
generate
the
following
triple
<ins class="diff-new">if
the
JSON-LD
document
is
mapped
to
RDF
</ins>
(in
N-Triples
notation):
</p>
<pre class="example">
&lt;http://example.org/people#joebob&gt; 
   &lt;http://www.w3.org/1999/02/22-rdf-syntax-ns#type&gt;
&lt;http://xmlns.com/foaf/0.1/Person&gt;
.
</pre>
</div>
<div id="strings" class="section">
<h3>
<span class="secno">
<del class="diff-old">4.4
</del>
<ins class="diff-chg">3.4
</ins>
</span>
<del class="diff-old">Plain
Literals
</del>
<ins class="diff-chg">Strings
</ins>
</h3>
<p>
Regular
text
<del class="diff-old">strings
are
called
a
</del>
<ins class="diff-chg">strings,
also
refered
to
as
</ins>
<dfn title="plain_literal" id="dfn-plain_literal">
plain
literal
</dfn>
<del class="diff-old">in
RDF
and
</del>
<ins class="diff-chg">s,
</ins>
are
easily
expressed
using
regular
JSON
strings.
</p>
<pre class="example">
{
...
  "foaf:name": "<span class="diff">Mark Birbeck</span>",
...
}
</pre>
</div>
<div id="string-internationalization" class="section">
<h3>
<span class="secno">
<del class="diff-old">4.5
</del>
<ins class="diff-chg">3.5
</ins>
</span>
<del class="diff-old">Language
Specification
in
Plain
Literals
</del>
<ins class="diff-chg">String
Internationalization
</ins>
</h3>
<p>
JSON-LD
makes
an
assumption
that
<del class="diff-old">plain
literal
s
</del>
<ins class="diff-chg">strings
</ins>
with
associated
language
encoding
information
<del class="diff-old">is
</del>
<ins class="diff-chg">are
</ins>
not
very
common
when
used
in
JavaScript
and
Web
Services.
Thus,
it
takes
a
little
more
effort
to
express
<del class="diff-old">plain
literals
in
a
specified
language.
</del>
<ins class="diff-chg">strings
with
associated
language
information.
</ins>
</p>
<pre class="example">
{
...
  "foaf:name": <span class="diff">
  {
    "@literal": "花澄",
    "@language": "ja"
  }</span>
...
}
</pre>
<p>
The
example
above
would
generate
a
<a class="tref internalDFN" title="plain_literal" href="#dfn-plain_literal">
plain
literal
</a>
for
<em>
花澄
</em>
and
associate
the
<code>
ja
</code>
language
<del class="diff-old">tag
</del>
<ins class="diff-chg">code
</ins>
with
the
triple
that
is
generated.
Languages
<em class="rfc2119" title="must">
must
</em>
be
expressed
in
[
<cite>
<a class="bibref" rel="biblioentry" href="#bib-BCP47">
BCP47
</a>
</cite>
]
format.
</p>
</div>
<div id="datatypes" class="section">
<h3>
<span class="secno">
<del class="diff-old">4.6
</del>
<ins class="diff-chg">3.6
</ins>
</span>
<del class="diff-old">Typed
Literals
</del>
<ins class="diff-chg">Datatypes
</ins>
</h3>
<p>
A
<ins class="diff-new">value
with
an
associated
datatype,
also
known
as
a
</ins>
<dfn title="typed_literal" id="dfn-typed_literal">
typed
literal
</dfn>,
is
indicated
by
<del class="diff-old">attaching
a
IRI
to
the
end
of
</del>
<ins class="diff-chg">associating
</ins>
a
<del class="diff-old">plain
</del>
literal
<del class="diff-old">,
and
this
</del>
<ins class="diff-chg">with
an
</ins>
IRI
<ins class="diff-new">which
</ins>
indicates
the
<ins class="diff-new">typed
</ins>
literal's
datatype.
<del class="diff-old">Literals
</del>
<ins class="diff-chg">Typed
literals
</ins>
may
be
<del class="diff-old">typed
</del>
<ins class="diff-chg">expressed
</ins>
in
JSON-LD
in
three
ways:
</p>
<ol>
<li>
By
utilizing
the
<code>
@coerce
</code>
keyword.
</li>
<li>
By
utilizing
the
expanded
form
for
specifying
objects.
</li>
<li>
By
using
a
native
JSON
datatype.
</li>
</ol>
<p>
The
first
example
uses
the
<code>
@coerce
</code>
keyword
to
express
a
typed
literal:
</p>
<pre class="example">
{<span class="diff">
  "@context": 
<del class="diff-old">  { 
</del>
<ins class="diff-chg">  {
    "dc":  "http://purl.org/dc/terms/",
    "xsd": "http://www.w3.org/2001/XMLSchema#"
</ins>
    "@coerce": 
    {
      "xsd:dateTime": "dc:modified"
    }
  }</span>
...
  "dc:modified": "2010-05-29T14:17:39+02:00",
...
}
</pre>
<p>
The
second
example
uses
the
expanded
form
for
specifying
objects:
</p>
<pre class="example">
{
...
  "dc:modified": <span class="diff">
  {
    "@literal": "2010-05-29T14:17:39+02:00",
    "@datatype": "xsd:dateTime"
  }</span>
...
}
</pre>
<p>
Both
examples
above
would
generate
an
object
with
the
literal
value
of
<code>
2010-05-29T14:17:39+02:00
</code>
and
the
datatype
of
<code>
http://www.w3.org/2001/XMLSchema#dateTime
</code>.
</p>
<p>
<ins class="diff-new">The
third
example
uses
a
built-in
native
JSON
type,
a
number,
to
express
a
datatype:
</ins></p><pre class="example"><ins class="diff-new">
{
...
  "@subject": "http://example.org/people#joebob",
  "foaf:age": <span class="diff">31</span>
...
}
</ins></pre><p><ins class="diff-new">
The
example
above
would
generate
the
following
triple:
</ins></p><pre class="example"><ins class="diff-new">
&lt;http://example.org/people#joebob&gt; 
   &lt;http://xmlns.com/foaf/0.1/age&gt; 
"31"^^&lt;http://www.w3.org/2001/XMLSchema#integer&gt;
.
</ins></pre>
</div>
<div id="multiple-objects-for-a-single-property" class="section">
<h3>
<span class="secno">
<del class="diff-old">4.7
</del>
<ins class="diff-chg">3.7
</ins>
</span>
Multiple
Objects
for
a
Single
Property
</h3>
<p>
A
JSON-LD
author
can
express
multiple
triples
in
a
compact
way
by
using
arrays.
If
a
subject
has
multiple
values
for
the
same
property,
the
author
<em class="rfc2119" title="may">
may
</em>
express
each
property
as
an
array.
</p>
<p class="note">
<ins class="diff-new">In
JSON-LD,
Multiple
objects
on
a
property
are
not
ordered.
This
is
because
typically
graphs
are
not
inherently
ordered
data
structures.
To
see
more
on
creating
ordered
collections
in
JSON-LD,
see
</ins><a href="#lists"><ins class="diff-new">
Lists
</ins></a>.</p>
<pre class="example">
{
...
<del class="diff-old">  "@": "http://example.org/people#joebob",
</del>
<ins class="diff-chg">  "@subject": "http://example.org/people#joebob",
</ins>
  "foaf:nick": <span class="diff">["joe", "bob", "jaybee"]</span>,
...
}
</pre>
<p>
The
markup
shown
above
would
generate
the
following
triples:
</p>
<pre class="example">
&lt;http://example.org/people#joebob&gt; 
   &lt;http://xmlns.com/foaf/0.1/nick&gt;
      "joe" .
&lt;http://example.org/people#joebob&gt; 
   &lt;http://xmlns.com/foaf/0.1/nick&gt;
      "bob" .
&lt;http://example.org/people#joebob&gt; 
   &lt;http://xmlns.com/foaf/0.1/nick&gt;
"jaybee"
.
</pre>
</div>
<div id="multiple-typed-literals-for-a-single-property" class="section">
<h3>
<span class="secno">
<del class="diff-old">4.8
</del>
<ins class="diff-chg">3.8
</ins>
</span>
Multiple
Typed
Literals
for
a
Single
Property
</h3>
<p>
Multiple
<a class="tref internalDFN" title="typed_literal" href="#dfn-typed_literal">
typed
literal
</a>
s
may
also
be
expressed
using
the
expanded
form
for
objects:
</p>
<pre class="example">
{
...
<del class="diff-old">  "@": "http://example.org/articles/8",
</del>
<ins class="diff-chg">  "@subject": "http://example.org/articles/8",
</ins>
  "dcterms:modified": <span class="diff">
  [
    {
      "@literal": "2010-05-29T14:17:39+02:00",
      "@datatype": "xsd:dateTime"
    },
    {
      "@literal": "2010-05-30T09:21:28-04:00",
      "@datatype": "xsd:dateTime"
    }
  ]</span>
...
}
</pre>
<p>
The
markup
shown
above
would
generate
the
following
triples:
</p>
<pre class="example">
&lt;http://example.org/articles/8&gt; 
   &lt;http://purl.org/dc/terms/modified&gt;
      "2010-05-29T14:17:39+02:00"^^http://www.w3.org/2001/XMLSchema#dateTime .
&lt;http://example.org/articles/8&gt; 
   &lt;http://purl.org/dc/terms/modified&gt;
"2010-05-30T09:21:28-04:00"^^http://www.w3.org/2001/XMLSchema#dateTime
.
</pre>
</div>
<div id="expansion" class="section">
<h3>
<span class="secno">
<del class="diff-old">4.9
</del>
<ins class="diff-chg">3.9
</ins>
</span>
<del class="diff-old">Blank
Nodes
</del>
<ins class="diff-chg">Expansion
</ins>
</h3>
<p>
<del class="diff-old">At
times,
it
becomes
necessary
to
be
able
to
express
information
without
being
able
</del>
<ins class="diff-chg">Expansion
is
the
process
of
taking
a
JSON-LD
document
and
applying
a
context
such
that
all
IRI,
datatypes,
and
literal
values
are
expanded
so
that
the
context
is
no
longer
necessary.
JSON-LD
document
expansion
is
typically
used
when
re-mapping
JSON-LD
documents
</ins>
to
<del class="diff-old">specify
</del>
<ins class="diff-chg">application-specific
JSON
documents
or
as
a
part
of
</ins>
the
<del class="diff-old">subject.
Typically,
this
</del>
<a href="#normalization">
<ins class="diff-chg">Normalization
</ins></a><ins class="diff-chg">
process.
</ins></p><p><ins class="diff-chg">
For
example,
assume
the
following
JSON-LD
input
document:
</ins></p><pre class="example"><ins class="diff-chg">
{
   "name": "Manu Sporny",
   "homepage": "http://manu.sporny.org/",
   "@context": 
   {
      "name": "http://xmlns.com/foaf/0.1/name",
      "homepage": "http://xmlns.com/foaf/0.1/homepage",
      "@coerce": 
      {
         "@iri": "homepage"
      }
   }
}
</ins></pre><p><ins class="diff-chg">
Running
the
JSON-LD
Expansion
algorithm
against
the
JSON-LD
input
document
provided
above
would
result
in
the
following
output:
</ins></p><pre class="example"><ins class="diff-chg">
{
   "http://xmlns.com/foaf/0.1/name": "Manu Sporny",
   "http://xmlns.com/foaf/0.1/homepage": 
   {
      "@iri": "http://manu.sporny.org/"
   }
}
</ins></pre></div><div id="compaction" class="section"><h3><span class="secno"><ins class="diff-chg">
3.10
</ins></span><ins class="diff-chg">
Compaction
</ins></h3><p><ins class="diff-chg">
Compaction
</ins>
is
<del class="diff-old">where
blank
nodes
come
into
play.
In
JSON-LD,
blank
node
identifiers
</del>
<ins class="diff-chg">the
process
of
taking
a
JSON-LD
document
and
applying
a
context
such
that
the
most
compact
form
of
the
document
is
generated.
JSON
is
typically
expressed
in
a
very
compact,
key-value
format.
That
is,
full
IRIs
</ins>
are
<del class="diff-old">automatically
created
if
</del>
<ins class="diff-chg">rarely
used
as
keys.
At
times,
</ins>
a
<del class="diff-old">subject
</del>
<ins class="diff-chg">JSON-LD
document
may
be
received
that
</ins>
is
not
<del class="diff-old">specified
using
</del>
<ins class="diff-chg">in
its
most
compact
form.
JSON-LD,
via
</ins>
the
<del class="diff-old">@
keyword.
However,
authors
may
name
blank
nodes
by
using
</del>
<ins class="diff-chg">API,
provides
a
way
to
compact
a
JSON-LD
document.
</ins></p><p><ins class="diff-chg">
For
example,
assume
</ins>
the
<del class="diff-old">special
_
CURIE
prefix.
</del>
<ins class="diff-chg">following
JSON-LD
input
document:
</ins>
</p>
<pre class="example">
{
<del class="diff-old">...
  "@": "",
...
</del>
<ins class="diff-chg">   "http://xmlns.com/foaf/0.1/name": "Manu Sporny",
   "http://xmlns.com/foaf/0.1/homepage": 
   {
      "@iri": "http://manu.sporny.org/"
   }
</ins>
}
</pre>
<p>
<del class="diff-old">The
example
</del>
<ins class="diff-chg">Additionally,
assume
the
following
developer-supplied
JSON-LD
context:
</ins></p><pre class="example"><ins class="diff-chg">
{
   "name": "http://xmlns.com/foaf/0.1/name",
   "homepage": "http://xmlns.com/foaf/0.1/homepage",
   "@coerce": 
   {
      "@iri": ["homepage"]
   }
}
</ins></pre><p><ins class="diff-chg">
Running
the
JSON-LD
Compaction
algorithm
given
the
context
supplied
above
against
the
JSON-LD
input
document
provided
</ins>
above
would
<del class="diff-old">set
</del>
<ins class="diff-chg">result
in
</ins>
the
<del class="diff-old">subject
</del>
<ins class="diff-chg">following
output:
</ins></p><pre class="example"><ins class="diff-chg">
{
   "name": "Manu Sporny",
   "homepage": "http://manu.sporny.org/",
   "@context": 
   {
      "name": "http://xmlns.com/foaf/0.1/name",
      "homepage": "http://xmlns.com/foaf/0.1/homepage",
      "@coerce": 
      {
         "@iri": "homepage"
      }
   }
}
</ins></pre><p><ins class="diff-chg">
The
compaction
algorithm
also
enables
the
developer
</ins>
to
<ins class="diff-new">map
any
expanded
format
into
an
application-specific
compacted
format.
While
the
context
provided
above
mapped
</ins>
<code>
<del class="diff-old">_:foo
,
which
</del>
<ins class="diff-chg">http://xmlns.com/foaf/0.1/name
</ins></code><ins class="diff-chg">
to
</ins><strong><ins class="diff-chg">
name
</ins></strong>,<ins class="diff-chg">
it
could
have
also
mapped
it
to
any
arbitrary
string
provided
by
the
developer.
</ins></p></div><div id="framing" class="section"><h3><span class="secno"><ins class="diff-chg">
3.11
</ins></span><ins class="diff-chg">
Framing
</ins></h3><p><ins class="diff-chg">
A
JSON-LD
document
is
a
representation
of
a
directed
graph.
A
single
directed
graph
can
have
many
different
serializations,
each
expressing
exactly
the
same
information.
Developers
typically
work
with
trees,
also
called
associative
arrays,
when
dealing
with
JSON.
While
mapping
a
graph
to
a
tree
can
be
done,
the
layout
of
the
end
result
must
be
specified
in
advance.
A
</ins><dfn title="Frame" id="dfn-frame"><ins class="diff-chg">
Frame
</ins></dfn>
can
<del class="diff-old">then
</del>
be
used
<del class="diff-old">later
</del>
<ins class="diff-chg">by
a
developer
</ins>
on
<ins class="diff-new">a
JSON-LD
document
to
specify
a
deterministic
layout
for
a
graph.
</ins></p><p><ins class="diff-new">
Framing
is
the
process
of
taking
a
JSON-LD
document,
which
expresses
a
graph
of
information,
and
applying
a
specific
graph
layout
(called
a
</ins><a class="tref internalDFN" title="Frame" href="#dfn-frame"><ins class="diff-new">
Frame
</ins></a><ins class="diff-new">
).
</ins></p><p><ins class="diff-new">
The
JSON-LD
document
below
expresses
a
library,
a
book
and
a
chapter:
</ins></p><pre class="example"><ins class="diff-new">
{
   "@coerce": {
    "dc":  "http://purl.org/dc/terms/",
    "ex":  "http://example.org/"
   },
   "@subject": 
   [{
      "@subject": "http://example.org/library",
      "@type": "ex:Library",
      "ex:contains": "http://example.org/library/the-republic"
   }, 
   {
      "@subject": "http://example.org/library/the-republic",
      "@type": "ex:Book",
      "dc:creator": "Plato",
      "dc:title": "The Republic",
      "ex:contains": "http://example.org/library/the-republic#introduction"
   }, 
   {
      "@subject": "http://example.org/library/the-republic#introduction",
      "@type": "ex:Chapter",
      "dc:description": "An introductory chapter on The Republic.",
      "dc:title": "The Introduction"
   }],
   "@context": 
   {
      "@coerce": 
      {
         "@iri": "ex:contains"
      },
      "dc": "http://purl.org/dc/elements/1.1/",
      "ex": "http://example.org/vocab#"
   }
}
</ins></pre><p><ins class="diff-new">
Developers
typically
like
to
operate
on
items
in
a
hierarchical,
tree-based
fashion.
Ideally,
a
developer
would
want
the
data
above
sorted
into
top-level
libraries,
then
the
books
that
are
contained
in
each
library,
and
then
the
chapters
contained
</ins>
in
<ins class="diff-new">each
book.
To
achieve
that
layout,
the
developer
can
define
the
following
</ins><a class="tref internalDFN" title="frame" href="#dfn-frame"><ins class="diff-new">
frame
</ins></a>:</p><pre class="example"><ins class="diff-new">
{
   "@context": {
      "dc": "http://purl.org/dc/elements/1.1/",
      "ex": "http://example.org/vocab#"
   },
   "@type": "ex:Library",
   "ex:contains": {
      "@type": "ex:Book",
      "ex:contains": {
         "@type": "ex:Chapter"
      }
   }
}
</ins></pre><p><ins class="diff-new">
When
the
framing
algorithm
is
run
against
</ins>
the
<ins class="diff-new">previously
defined
</ins>
JSON-LD
<del class="diff-old">markup
</del>
<ins class="diff-chg">document,
paired
with
the
</ins><a class="tref internalDFN" title="frame" href="#dfn-frame"><ins class="diff-chg">
frame
</ins></a><ins class="diff-chg">
above,
the
following
JSON-LD
document
is
the
end
result:
</ins></p><pre class="example"><ins class="diff-chg">
{
   "@context": 
   {
      "ex": "http://example.org/vocab#",
      "dc":  "http://purl.org/dc/terms/",
   }
   "@subject": "http://example.org/library",
   "@type": "ex:Library",
   "ex:contains": 
   {
      "@subject": "http://example.org/library/the-republic",
      "@type": "ex:Book",
      "dc:creator": "Plato",
      "dc:title": "The Republic",
      "ex:contains": 
      {
         "@subject": "http://example.org/library/the-republic#introduction",
         "@type": "ex:Chapter",
         "dc:description": "An introductory chapter on The Republic.",
         "dc:title": "The Introduction"
      },
   },
}
</ins></pre><p><ins class="diff-chg">
The
JSON-LD
framing
algorithm
allows
developers
</ins>
to
<del class="diff-old">refer
back
</del>
<ins class="diff-chg">query
by
example
and
force
a
specific
tree
layout
</ins>
to
<del class="diff-old">the
named
blank
node.
</del>
<ins class="diff-chg">a
JSON-LD
document.
</ins>
</p>
</div>
</div>
<div id="advanced-concepts" class="section">
<h2>
<span class="secno">
<del class="diff-old">5.
</del>
<ins class="diff-chg">4.
</ins>
</span>
Advanced
<del class="diff-old">Features
</del>
<ins class="diff-chg">Concepts
</ins>
</h2>
<p>
JSON-LD
has
a
number
of
features
that
provide
functionality
above
and
beyond
the
core
functionality
<del class="diff-old">provided
by
RDF.
</del>
<ins class="diff-chg">described
above.
</ins>
The
following
sections
outline
the
features
that
are
specific
to
JSON-LD.
</p>
<div id="automatic-typing" class="section">
<h3>
<span class="secno">
<del class="diff-old">5.1
</del>
<ins class="diff-chg">4.1
</ins>
</span>
Automatic
Typing
</h3>
<p>
Since
JSON
is
capable
of
expressing
typed
information
such
as
doubles,
integers,
and
boolean
values.
As
demonstrated
below,
JSON-LD
utilizes
that
information
to
create
<a class="tref internalDFN" title="typed_literal" href="#dfn-typed_literal">
typed
literal
</a>
s:
</p>
<pre class="example">
{
...
  // The following two values are automatically converted to a type of xsd:double
  // and both values are equivalent to each other.
  "measure:cups": <span class="diff">5.3</span>,
  "measure:cups": <span class="diff">5.3e0</span>,
  // The following value is automatically converted to a type of xsd:double as well
  "space:astronomicUnits": <span class="diff">6.5e73</span>,
  // The following value should never be converted to a language-native type
  "measure:stones": <span class="diff">{ "@literal": "4.8", "@datatype": "xsd:decimal" }</span>,
  // This value is automatically converted to having a type of xsd:integer
  "chem:protons": <span class="diff">12</span>,
  // This value is automatically converted to having a type of xsd:boolean
  "sensor:active": <span class="diff">true</span>,
...
}
</pre>
<p class="note">
When
dealing
with
a
number
of
modern
programming
languages,
including
JavaScript
ECMA-262,
there
is
no
distinction
between
<strong>
xsd:decimal
</strong>
and
<strong>
xsd:double
</strong>
values.
That
is,
the
number
<code>
5.3
</code>
and
the
number
<code>
5.3e0
</code>
are
treated
as
if
they
were
the
same.
When
converting
from
JSON-LD
to
a
language-native
format
and
back,
datatype
information
is
lost
in
a
number
of
these
languages.
Thus,
one
could
say
that
<code>
5.3
</code>
is
a
<strong>
xsd:decimal
</strong>
and
<code>
5.3e0
</code>
is
an
<strong>
xsd:double
</strong>
in
JSON-LD,
but
when
both
values
are
converted
to
a
language-native
format
the
datatype
difference
between
the
two
is
lost
because
the
machine-level
representation
will
almost
always
be
a
<strong>
double
</strong>.
Implementers
should
be
aware
of
this
potential
round-tripping
issue
between
<strong>
xsd:decimal
</strong>
and
<strong>
xsd:double
</strong>.
Specifically
objects
with
a
datatype
of
<strong>
xsd:decimal
</strong>
<em class="rfc2119" title="must not">
must
not
</em>
be
converted
to
a
language
native
type.
</p>
</div>
<div id="type-coercion" class="section">
<h3>
<span class="secno">
<del class="diff-old">5.2
</del>
<ins class="diff-chg">4.2
</ins>
</span>
Type
Coercion
</h3>
<p>
JSON-LD
supports
the
coercion
of
<del class="diff-old">types
</del>
<ins class="diff-chg">values
</ins>
to
<del class="diff-old">ensure
that
the
zero-edit
goal
of
JSON-LD
can
be
accomplished.
</del>
<ins class="diff-chg">particular
data
types.
</ins>
Type
coercion
allows
someone
deploying
JSON-LD
to
coerce
<del class="diff-old">and
</del>
<ins class="diff-chg">the
</ins>
incoming
or
outgoing
types
to
the
proper
<del class="diff-old">RDF
</del>
<ins class="diff-chg">data
</ins>
type
based
on
a
mapping
of
<ins class="diff-new">data
</ins>
type
IRIs
to
<del class="diff-old">RDF
</del>
<ins class="diff-chg">property
</ins>
types.
Using
type
<del class="diff-old">conversion,
</del>
<ins class="diff-chg">coercion,
</ins>
one
may
convert
simple
JSON
data
to
properly
typed
RDF
data.
</p>
<p>
The
example
below
demonstrates
how
a
JSON-LD
author
can
coerce
values
to
<a class="tref internalDFN" title="plain_literal" href="#dfn-plain_literal">
plain
literal
</a>
s,
<a class="tref internalDFN" title="typed_literal" href="#dfn-typed_literal">
typed
literal
</a>
s
and
IRIs.
</p>
<pre class="example">
{
  "@context": 
  {  
     "rdf": "http://www.w3.org/1999/02/22-rdf-syntax-ns#",
     "xsd": "http://www.w3.org/2001/XMLSchema#",
     "name": "http://xmlns.com/foaf/0.1/name",
     "age": "http://xmlns.com/foaf/0.1/age",
     "homepage": "http://xmlns.com/foaf/0.1/homepage",
<span class="diff">     "@coerce":
     {
        "xsd:integer": "age",
<del class="diff-old">        "xsd:anyURI": "homepage",
</del>
<ins class="diff-chg">        "@iri": "homepage"
</ins>
     }</span>
  },
  "name": "John Smith",
  "age": <span class="diff">"41"</span>,
  "homepage": <span class="diff">"http://example.org/home/"</span>
}
</pre>
<p>
The
example
above
would
generate
the
following
triples:
</p>
<pre class="example">
_:bnode1
   &lt;http://xmlns.com/foaf/0.1/name&gt;
      "John Smith" .
_:bnode1
   &lt;http://xmlns.com/foaf/0.1/age&gt;
      "41"^^http://www.w3.org/2001/XMLSchema#integer .
_:bnode1
   &lt;http://xmlns.com/foaf/0.1/homepage&gt;
&lt;http://example.org/home/&gt;
.
</pre>
</div>
<div id="chaining" class="section">
<h3>
<span class="secno">
<del class="diff-old">6.
</del>
<ins class="diff-chg">4.3
</ins>
</span>
<del class="diff-old">The
JSON-LD
Processing
Algorithm
</del>
<ins class="diff-chg">Chaining
</ins></h3>
<p>
<del class="diff-old">The
JSON-LD
Processing
Model
describes
processing
rules
for
extracting
RDF
from
</del>
<ins class="diff-chg">Object
</ins><dfn title="chaining" id="dfn-chaining"><ins class="diff-chg">
chaining
</ins></dfn><ins class="diff-chg">
is
</ins>
a
JSON-LD
<del class="diff-old">document.
Note
</del>
<ins class="diff-chg">feature
</ins>
that
<del class="diff-old">many
uses
</del>
<ins class="diff-chg">allows
an
author
to
use
the
definition
</ins>
of
JSON-LD
<del class="diff-old">may
not
require
generation
of
RDF.
</del>
<ins class="diff-chg">objects
as
</ins><a class="tref internalDFN" title="property" href="#dfn-property"><ins class="diff-chg">
property
</ins></a><ins class="diff-chg">
values.
This
is
a
commonly
used
mechanism
for
creating
a
parent-child
relationship
between
two
</ins><a class="tref internalDFN" title="subject" href="#dfn-subject"><ins class="diff-chg">
subject
</ins></a><ins class="diff-chg">
s.
</ins>
</p>
<p>
The
<del class="diff-old">processing
algorithm
described
in
this
section
is
provided
in
order
to
demonstrate
how
one
might
implement
</del>
<ins class="diff-chg">example
shows
an
two
subjects
related
by
</ins>
a
<del class="diff-old">JSON-LD
processor.
Conformant
implementations
are
only
required
to
produce
the
same
type
and
number
of
triples
during
</del>
<ins class="diff-chg">property
from
</ins>
the
<del class="diff-old">output
process
and
are
not
required
to
implement
</del>
<ins class="diff-chg">first
subject:
</ins></p>  <pre class="example"><ins class="diff-chg">
{
...
  "foaf:name": "Manu Sporny",
  "<span class="diff">foaf:knows</span>": {
    "<span class="diff">@type</span>": "<span class="diff">foaf:Person</span>",
    "<span class="diff">foaf:name</span>": "<span class="diff">Gregg Kellogg</span>",
  }
...
}
</ins></pre><p><ins class="diff-chg">
An
object
definition,
like
</ins>
the
<del class="diff-old">algorithm
exactly
</del>
<ins class="diff-chg">one
used
above,
</ins><em class="rfc2119" title="may"><ins class="diff-chg">
may
</ins></em><ins class="diff-chg">
be
used
</ins>
as
<del class="diff-old">described.
The
Processing
Algorithm
is
</del>
a
<del class="diff-old">work
</del>
<ins class="diff-chg">JSON
value
at
any
point
</ins>
in
<del class="diff-old">progress.
</del>
<ins class="diff-chg">JSON-LD.
</ins>
</p>
</div>
<div id="identifying-unlabeled-nodes" class="section">
<h3>
<span class="secno">
<del class="diff-old">6.1
</del>
<ins class="diff-chg">4.4
</ins>
</span>
<del class="diff-old">Overview
</del>
<ins class="diff-chg">Identifying
Unlabeled
Nodes
</ins>
</h3>
<p>
<del class="diff-old">This
section
is
non-normative.
JSON-LD
is
intended
</del>
<ins class="diff-chg">At
times,
it
becomes
necessary
</ins>
to
<del class="diff-old">have
an
easy
</del>
<ins class="diff-chg">be
able
</ins>
to
<del class="diff-old">parse
grammar
that
closely
models
existing
practice
in
using
JSON
for
describing
object
representations.
This
allows
</del>
<ins class="diff-chg">express
information
without
being
able
to
specify
</ins>
the
<del class="diff-old">use
</del>
<ins class="diff-chg">subject.
Typically,
this
type
</ins>
of
<del class="diff-old">existing
libraries
for
parsing
JSON
in
a
document-oriented
fashion,
</del>
<ins class="diff-chg">node
is
called
an
unlabeled
node
</ins>
or
<del class="diff-old">can
allow
for
stream-based
parsing
similar
to
SAX.
As
with
other
grammars
used
for
describing
linked
data,
</del>
a
<del class="diff-old">key
concept
is
that
of
</del>
<ins class="diff-chg">blank
node.
In
JSON-LD,
unlabeled
node
identifiers
are
automatically
created
if
</ins>
a
<del class="diff-old">resource
.
Resources
</del>
<ins class="diff-chg">subject
is
not
specified
using
the
</ins><code><ins class="diff-chg">
@subject
</ins></code><ins class="diff-chg">
keyword.
However,
authors
</ins>
may
<del class="diff-old">be
of
three
basic
types:
IRI
s,
for
describing
externally
named
entities,
BNodes
,
resources
</del>
<ins class="diff-chg">provide
identifiers
</ins>
for
<ins class="diff-new">unlabeled
nodes
by
using
the
special
</ins><code><ins class="diff-new">
_
</ins></code><ins class="diff-new">
(underscore)
CURIE
prefix.
</ins></p><pre class="example"><ins class="diff-new">
{
...
  "@subject": "<span class="diff">_:foo</span>",
...
}
</ins></pre><p><ins class="diff-new">
The
example
above
would
set
the
subject
to
</ins><code><ins class="diff-new">
_:foo
</ins></code>,
which
<del class="diff-old">an
external
name
does
not
exist,
or
</del>
<ins class="diff-chg">can
then
be
used
later
on
in
the
JSON-LD
markup
to
refer
back
to
the
unlabeled
node.
This
practice,
however,
</ins>
is
<del class="diff-old">not
known,
and
Literals,
which
describe
terminal
entities
such
as
strings,
dates
and
other
representations
having
</del>
<ins class="diff-chg">usually
frowned
upon
when
generating
Linked
Data.
If
</ins>
a
<del class="diff-old">lexical
representation
possibly
including
an
explicit
language
or
datatype.
</del>
<ins class="diff-chg">developer
finds
that
they
refer
to
the
unlabeled
node
more
than
once,
they
should
consider
naming
the
node
using
a
resolve-able
IRI.
</ins>
</p>
</div>
<div id="overriding-keywords" class="section">
<h3>
<span class="secno">
<ins class="diff-new">4.5
</ins></span><ins class="diff-new">
Overriding
Keywords
</ins></h3>
<p>
<del class="diff-old">Data
described
with
</del>
JSON-LD
<del class="diff-old">may
</del>
<ins class="diff-chg">allows
all
of
the
syntax
keywords,
except
for
</ins><code><ins class="diff-chg">
@context
</ins></code>,<ins class="diff-chg">
to
</ins>
be
<del class="diff-old">considered
</del>
<ins class="diff-chg">overridden.
This
feature
allows
more
legacy
JSON
content
</ins>
to
be
<del class="diff-old">the
representation
of
a
graph
made
up
of
subject
and
object
resources
related
via
a
predicate
resource.
However,
specific
implementations
may
choose
</del>
<ins class="diff-chg">supported
by
JSON-LD.
It
also
allows
developers
</ins>
to
<del class="diff-old">operate
on
</del>
<ins class="diff-chg">design
domain-specific
implementations
using
only
</ins>
the
<del class="diff-old">document
as
</del>
<ins class="diff-chg">JSON-LD
context.
</ins></p><pre class="example"><ins class="diff-chg">
{
  "@context": 
  {  
</ins>     <span class="diff">"url": "@subject"</span>,     <span class="diff">"a": "@type"</span>,<ins class="diff-chg">
     "name": "http://schema.org/name"
  },
  "url": "http://example.com/about#gregg",
  "a": "http://schema.org/Person",
  "name": "Gregg Kellogg"
}
</ins></pre><p><ins class="diff-chg">
In
the
example
above,
the
</ins><code><ins class="diff-chg">
@subject
</ins></code><ins class="diff-chg">
and
</ins><code><ins class="diff-chg">
@type
</ins></code><ins class="diff-chg">
keywords
have
been
overridden
by
</ins><strong><ins class="diff-chg">
url
</ins></strong><ins class="diff-chg">
and
</ins><strong>
a
<del class="diff-old">normal
JSON
description
of
objects
having
attributes.
</del>
</strong>,
<ins class="diff-chg">respectively.
</ins>
</p>
</div>
<div id="normalization" class="section">
<h3>
<span class="secno">
<del class="diff-old">6.2
</del>
<ins class="diff-chg">4.6
</ins>
</span>
<del class="diff-old">Processing
Algorithm
Terms
</del>
<ins class="diff-chg">Normalization
</ins>
</h3>
<del class="diff-old">default
context
a
context
that
</del>
<p>
<ins class="diff-chg">Normalization
</ins>
is
<del class="diff-old">specified
to
</del>
the
<ins class="diff-new">process
of
taking
</ins><a class="tref internalDFN" title="JSON-LD_input" href="#dfn-json-ld_input">
JSON-LD
<del class="diff-old">processing
algorithm
before
processing
begins.
default
graph
</del>
<ins class="diff-chg">input
</ins></a><ins class="diff-chg">
and
performing
a
deterministic
transformation
on
that
input
that
results
in
a
</ins><a class="tref internalDFN" title="JSON-LD_output" href="#dfn-json-ld_output"><ins class="diff-chg">
JSON-LD
output
</ins></a><ins class="diff-chg">
that
any
conforming
JSON-LD
processor
would
have
generated
given
</ins>
the
<del class="diff-old">destination
</del>
<ins class="diff-chg">same
input.
The
problem
is
a
fairly
difficult
technical
problem
to
solve
because
it
requires
a
directed
</ins>
graph
<del class="diff-old">for
</del>
<ins class="diff-chg">to
be
ordered
into
a
set
of
nodes
and
edges
in
a
deterministic
way.
This
is
easy
to
do
when
</ins>
all
<del class="diff-old">triples
generated
by
JSON-LD
markup.
active
subject
</del>
<ins class="diff-chg">of
</ins>
the
<del class="diff-old">currently
active
subject
that
</del>
<ins class="diff-chg">nodes
have
unique
names,
but
very
difficult
to
do
when
some
of
</ins>
the
<del class="diff-old">processor
should
use
</del>
<ins class="diff-chg">nodes
are
not
labeled.
</ins></p><p><ins class="diff-chg">
Normalization
is
useful
when
comparing
two
graphs
against
one
another,
</ins>
when
generating
<del class="diff-old">triples.
active
property
the
currently
active
property
that
the
processor
should
use
</del>
<ins class="diff-chg">a
detailed
list
of
differences
between
two
graphs,
and
</ins>
when
generating
<del class="diff-old">triples.
active
object
the
currently
active
object
that
the
processor
should
use
</del>
<ins class="diff-chg">a
cryptographic
digital
signature
for
information
contained
in
a
graph
or
</ins>
when
generating
<del class="diff-old">triples.
active
context
</del>
a
<del class="diff-old">context
that
is
used
to
resolve
CURIEs
while
</del>
<ins class="diff-chg">hash
of
</ins>
the
<del class="diff-old">processing
algorithm
</del>
<ins class="diff-chg">information
contained
in
a
graph.
</ins></p><p><ins class="diff-chg">
The
example
below
</ins>
is
<del class="diff-old">running.
</del>
<ins class="diff-chg">an
un-normalized
JSON-LD
document:
</ins></p><pre class="example"><ins class="diff-chg">
{
   "name": "Manu Sporny",
   "homepage": "http://manu.sporny.org/",
   "@context": 
   {
      "name": "http://xmlns.com/foaf/0.1/name",
      "homepage": "http://xmlns.com/foaf/0.1/homepage",
      "xsd": "http://www.w3.org/2001/XMLSchema#",
      "@coerce": 
      {
         "@iri": ["homepage"]
      }
   }
}
</ins></pre><p>
The
<del class="diff-old">active
context
</del>
<ins class="diff-chg">example
below
</ins>
is
the
<del class="diff-old">context
contained
within
</del>
<ins class="diff-chg">normalized
form
of
</ins>
the
<del class="diff-old">processor
state
.
local
context
a
context
that
</del>
<ins class="diff-chg">JSON-LD
document
above:
</ins></p><p class="note"><ins class="diff-chg">
Whitespace
</ins>
is
<del class="diff-old">specified
at
the
JSON
associative-array
level,
specified
via
</del>
<ins class="diff-chg">used
below
to
aid
readability.
The
normalization
algorithm
for
JSON-LD
remove
all
unnecessary
whitespace
in
</ins>
the
<del class="diff-old">@context
keyword.
processor
state
</del>
<ins class="diff-chg">fully
normalized
form.
</ins></p><pre class="example"><ins class="diff-chg">
[{
    "@subject": 
    {
        "@iri": "_:c14n0"
    },
    "http://xmlns.com/foaf/0.1/homepage": 
    {
        "@iri": "http://manu.sporny.org/"
    },
    "http://xmlns.com/foaf/0.1/name": "Manu Sporny"
}]
</ins></pre><p><ins class="diff-chg">
Notice
how
all
of
</ins>
the
<del class="diff-old">processor
state
,
which
includes
</del>
<a class="tref internalDFN" title="term" href="#dfn-term">
<ins class="diff-chg">term
</ins></a><ins class="diff-chg">
s
have
been
expanded
and
sorted
in
alphabetical
order.
Also,
notice
how
</ins>
the
<del class="diff-old">active
context
,
current
</del>
<a class="tref internalDFN" title="subject" href="#dfn-subject">
subject
<del class="diff-old">,
and
current
property
.
The
processor
state
</del>
</a>
<del class="diff-old">is
managed
as
a
stack
</del>
<ins class="diff-chg">has
been
labeled
</ins>
with
<del class="diff-old">elements
from
the
previous
processor
state
copied
into
</del>
a
<del class="diff-old">new
processor
state
when
entering
a
new
associative
array.
</del>
<a class="tref internalDFN" title="blank_node_identifier" href="#dfn-blank_node_identifier-7">
<ins class="diff-chg">blank
node
identifier
</ins></a>.<ins class="diff-chg">
Normalization
ensures
that
any
arbitrary
graph
containing
exactly
the
same
information
would
be
normalized
to
exactly
the
same
form
shown
above.
</ins></p>
</div>
</div>
<div id="algorithms" class="section">
<h2>
<span class="secno">
<ins class="diff-chg">5.
</ins></span><ins class="diff-chg">
Algorithms
</ins></h2><p><ins class="diff-chg">
All
algorithms
described
in
this
section
are
intended
to
operate
on
language-native
data
structures.
That
is,
the
serialization
to
a
text-based
JSON
document
isn't
required
as
input
or
output
to
any
of
these
algorithms
and
language-native
data
structures
</ins><em class="rfc2119" title="must"><ins class="diff-chg">
must
</ins></em><ins class="diff-chg">
be
used
where
applicable.
</ins></p><div id="syntax-tokens-and-keywords" class="section">
<h3>
<span class="secno">
<del class="diff-old">6.3
</del>
<ins class="diff-chg">5.1
</ins>
</span>
<del class="diff-old">Processing
</del>
<ins class="diff-chg">Syntax
</ins>
Tokens
and
Keywords
</h3>
<p>
<ins class="diff-new">JSON-LD
specifies
a
number
of
syntax
tokens
and
keywords
that
are
using
in
all
algorithms
described
in
this
section:
</ins></p>
<dl>
<dt>
<code>
@context
</code>
</dt>
<dd>
Used
to
set
the
<a class="tref internalDFN" title="local_context" href="#dfn-local_context">
local
context
</a>.
</dd>
<dt>
<code>
@base
</code>
</dt>
<dd>
Used
to
set
the
base
IRI
for
all
object
IRIs
affected
by
the
<a class="tref internalDFN" title="active_context" href="#dfn-active_context">
active
context
</a>.
</dd>
<dt>
<code>
<del class="diff-old">@profile
A
reference
to
a
remote
context
description
used
to
set
the
local
context
.
</del>
@vocab
</code>
</dt>
<dd>
Used
to
set
the
base
IRI
for
all
property
IRIs
affected
by
the
<a class="tref internalDFN" title="active_context" href="#dfn-active_context">
active
context
</a>.
</dd>
<dt>
<code>
@coerce
</code>
</dt>
<dd>
Used
to
specify
type
coercion
rules.
</dd>
<dt>
<code>
@literal
</code>
</dt>
<dd>
Used
to
specify
a
literal
value.
</dd>
<dt>
<code>
@iri
</code>
</dt>
<dd>
Used
to
specify
an
IRI
value.
</dd>
<dt>
<code>
@language
</code>
</dt>
<dd>
Used
to
specify
the
language
for
a
literal.
</dd>
<dt>
<code>
@datatype
</code>
</dt>
<dd>
Used
to
specify
the
datatype
for
a
literal.
</dd>
<dt>
<code>:
</code>
</dt>
<dd>
The
separator
for
CURIEs
when
used
in
JSON
keys
or
JSON
values.
</dd>
<dt>
<code>
<del class="diff-old">@
</del>
<ins class="diff-chg">@subject
</ins>
</code>
</dt>
<dd>
Sets
the
active
subjects.
</dd>
<dt>
<code>
<del class="diff-old">a
</del>
<ins class="diff-chg">@type
</ins>
</code>
</dt>
<dd>
Used
to
set
the
<del class="diff-old">rdf:type
</del>
<ins class="diff-chg">type
</ins>
of
the
active
subjects.
<del class="diff-old">This
token
may
be
conferred
as
syntactic
sugar
for
rdf:type.
</del>
</dd>
</dl>
<del class="diff-old">Use
@source
instead
of
@
?
Use
</del>
</div>
<div id="algorithm-terms" class="section">
<h3>
<span class="secno">
<ins class="diff-chg">5.2
</ins></span><ins class="diff-chg">
Algorithm
Terms
</ins></h3><dl><dt><dfn title="initial_context" id="dfn-initial_context"><ins class="diff-chg">
initial
context
</ins></dfn></dt><dd><ins class="diff-chg">
a
context
that
is
specified
to
the
algorithm
before
processing
begins.
</ins></dd><dt><dfn title="active_subject" id="dfn-active_subject"><ins class="diff-chg">
active
subject
</ins></dfn></dt><dd><ins class="diff-chg">
the
currently
active
subject
that
the
processor
should
use
when
processing.
</ins></dd><dt><dfn title="active_property" id="dfn-active_property"><ins class="diff-chg">
active
property
</ins></dfn></dt><dd><ins class="diff-chg">
the
currently
active
property
that
the
processor
should
use
when
processing.
</ins></dd><dt><dfn title="active_object" id="dfn-active_object"><ins class="diff-chg">
active
object
</ins></dfn></dt><dd><ins class="diff-chg">
the
currently
active
object
that
the
processor
should
use
when
processing.
</ins></dd><dt><dfn title="active_context" id="dfn-active_context"><ins class="diff-chg">
active
context
</ins></dfn></dt><dd><ins class="diff-chg">
a
context
that
is
used
to
resolve
CURIEs
while
the
processing
algorithm
is
running.
The
</ins><a class="tref internalDFN" title="active_context" href="#dfn-active_context"><ins class="diff-chg">
active
context
</ins></a><ins class="diff-chg">
is
the
context
contained
within
the
</ins><a class="tref internalDFN" title="processor_state" href="#dfn-processor_state"><ins class="diff-chg">
processor
state
</ins></a>.</dd><dt><dfn title="local_context" id="dfn-local_context"><ins class="diff-chg">
local
context
</ins></dfn></dt><dd><ins class="diff-chg">
a
context
that
is
specified
at
the
JSON
associative-array
level,
specified
via
the
</ins>
<code>
<del class="diff-old">@type
</del>
<ins class="diff-chg">@context
</ins>
</code>
<del class="diff-old">instead
of
</del>
<ins class="diff-chg">keyword.
</ins></dd><dt><dfn title="processor_state" id="dfn-processor_state"><ins class="diff-chg">
processor
state
</ins></dfn></dt><dd><ins class="diff-chg">
the
</ins><a class="tref internalDFN" title="processor_state" href="#dfn-processor_state"><ins class="diff-chg">
processor
state
</ins></a>,<ins class="diff-chg">
which
includes
the
</ins><a class="tref" title="active__context"><ins class="diff-chg">
active
context
</ins></a>,<a class="tref" title="current_subject"><ins class="diff-chg">
current
subject
</ins></a>,<ins class="diff-chg">
and
</ins><a class="tref" title="current_property"><ins class="diff-chg">
current
property
</ins></a>.<ins class="diff-chg">
The
</ins><a class="tref internalDFN" title="processor_state" href="#dfn-processor_state"><ins class="diff-chg">
processor
state
</ins></a><ins class="diff-chg">
is
managed
as
</ins>
a
<del class="diff-old">?
Note
</del>
<ins class="diff-chg">stack
with
elements
from
the
previous
</ins><a class="tref internalDFN" title="processor_state" href="#dfn-processor_state"><ins class="diff-chg">
processor
state
</ins></a><ins class="diff-chg">
copied
into
a
new
</ins><a class="tref internalDFN" title="processor_state" href="#dfn-processor_state"><ins class="diff-chg">
processor
state
</ins></a><ins class="diff-chg">
when
entering
a
new
associative
array.
</ins></dd><dt><dfn title="JSON-LD_input" id="dfn-json-ld_input"><ins class="diff-chg">
JSON-LD
input
</ins></dfn></dt><dd><ins class="diff-chg">
The
JSON-LD
data
structure
</ins>
that
<del class="diff-old">both
are
just
semantic
sugar
for
rdf:type
.
</del>
<ins class="diff-chg">is
provided
as
input
to
the
algorithm.
</ins></dd><dt><dfn title="JSON-LD_output" id="dfn-json-ld_output"><ins class="diff-chg">
JSON-LD
output
</ins></dfn></dt><dd><ins class="diff-chg">
The
JSON-LD
data
structure
that
is
produced
as
output
by
the
algorithm.
</ins></dd></dl>
</div>
<div id="context-1" class="section">
<h3 id="context">
<span class="secno">
<del class="diff-old">6.4
</del>
<ins class="diff-chg">5.3
</ins>
</span>
Context
</h3>
<p>
Processing
of
JSON-LD
<ins class="diff-new">data
structure
</ins>
is
managed
<del class="diff-old">recursively
using
a
process
described
in
Sequence
.
</del>
<ins class="diff-chg">recursively.
</ins>
During
processing,
each
rule
is
applied
using
information
provided
by
the
<a class="tref internalDFN" title="active_context" href="#dfn-active_context">
active
context
</a>.
Processing
begins
by
pushing
a
new
<a class="tref internalDFN" title="processor_state" href="#dfn-processor_state">
processor
state
</a>
onto
the
<a class="tref internalDFN" title="processor_state" href="#dfn-processor_state">
processor
state
</a>
stack
and
initializing
the
<a class="tref internalDFN" title="active_context" href="#dfn-active_context">
active
context
</a>
with
the
<del class="diff-old">default
</del>
<a class="tref internalDFN" title="initial_context" href="#dfn-initial_context">
<ins class="diff-chg">initial
</ins>
context
</a>.
If
a
<a class="tref internalDFN" title="local_context" href="#dfn-local_context">
local
context
</a>
is
encountered,
information
from
the
<a class="tref internalDFN" title="local_context" href="#dfn-local_context">
local
context
</a>
is
merged
into
the
<a class="tref internalDFN" title="active_context" href="#dfn-active_context">
active
context
</a>.
</p>
<del class="diff-old">Should
the
document
URL
be
used
as
the
default
for
@base
in
the
default
context
?
</del>
<p>
The
<a class="tref internalDFN" title="active_context" href="#dfn-active_context">
active
context
</a>
is
used
for
expanding
keys
and
values
of
an
associative
array
(or
elements
of
a
list
(see
<span a="#list-processing">
List
Processing
</span>
)).
</p>
<p>
A
<a class="tref internalDFN" title="local_context" href="#dfn-local_context">
local
context
</a>
is
identified
within
an
associative
array
having
a
key
of
<code>
@context
</code>
with
<ins class="diff-new">string
or
</ins>
an
associative
array
value.
When
processing
a
<a class="tref" title="local__context">
local
context
</a>,
special
<ins class="diff-new">processing
</ins>
rules
apply:
</p>
<ol class="algorithm">
<li>
<del class="diff-old">The
key
</del>
<ins class="diff-chg">Create
a
new,
empty
</ins><a class="tref internalDFN" title="local_context" href="#dfn-local_context"><ins class="diff-chg">
local
context
</ins></a>.</li><li><ins class="diff-chg">
If
the
value
is
a
simple
string,
it
</ins><em class="rfc2119" title="must"><ins class="diff-chg">
must
</ins></em><ins class="diff-chg">
have
a
lexical
form
of
IRI
and
used
to
initialize
a
new
JSON
document
which
replaces
the
value
for
subsequent
processing.
</ins></li><li><ins class="diff-chg">
If
the
value
is
an
associative
array,
perform
the
following
steps:
</ins><ol class="algorithm"><li><ins class="diff-chg">
If
the
associative
array
has
a
</ins>
<code>
@base
</code>
<ins class="diff-new">key,
it
</ins>
<em class="rfc2119" title="must">
must
</em>
have
a
value
of
a
simple
string
with
the
lexical
form
of
<del class="diff-old">IRI
and
is
saved
in
</del>
<ins class="diff-chg">an
absolute
IRI.
Add
</ins>
the
<del class="diff-old">active
</del>
<ins class="diff-chg">base
mapping
to
the
</ins><a class="tref" title="local__context"><ins class="diff-chg">
local
</ins>
context
</a>.
<p class="issue">
<ins class="diff-chg">Turtle
allows
@base
</ins>
to
<del class="diff-old">perform
term
mapping
as
described
in
</del>
<ins class="diff-chg">be
relative.
If
we
did
this,
we
would
have
to
add
</ins><a href="#iri-expansion">
IRI
<del class="diff-old">Processing
</del>
<ins class="diff-chg">Expansion
</ins>
</a>.
</p>
</li>
<li>
<del class="diff-old">The
key
</del>
<ins class="diff-chg">If
the
associative
array
has
a
</ins>
<code>
@vocab
</code>
<ins class="diff-new">key,
it
</ins>
<em class="rfc2119" title="must">
must
</em>
have
a
value
of
a
simple
string
with
the
lexical
form
of
<del class="diff-old">IRI
and
is
saved
in
</del>
<ins class="diff-chg">an
absolute
IRI.
Add
</ins>
the
<del class="diff-old">active
</del>
<ins class="diff-chg">vocabulary
mapping
to
the
</ins><a class="tref internalDFN" title="local_context" href="#dfn-local_context"><ins class="diff-chg">
local
</ins>
context
</a>
<del class="diff-old">to
perform
term
mapping
as
described
in
</del>
<ins class="diff-chg">after
performing
</ins><a href="#iri-expansion">
IRI
<del class="diff-old">Processing
.
</del>
<ins class="diff-chg">Expansion
</ins></a><ins class="diff-chg">
on
the
associated
value.
</ins>
</li>
<li>
<del class="diff-old">The
key
</del>
<ins class="diff-chg">If
the
associative
array
has
a
</ins>
<code>
@coerce
</code>
<ins class="diff-new">key,
it
</ins>
<em class="rfc2119" title="must">
must
</em>
have
a
value
of
an
associative
array.
<del class="diff-old">Processing
of
</del>
<ins class="diff-chg">Add
</ins>
the
<del class="diff-old">associative
array
is
described
below
</del>
<code>
<ins class="diff-chg">@coerce
</ins></code><ins class="diff-chg">
mapping
to
the
</ins><a class="tref internalDFN" title="local_context" href="#dfn-local_context"><ins class="diff-chg">
local
context
</ins>
</a>
<ins class="diff-chg">performing
</ins><a href="#iri-expansion"><ins class="diff-chg">
IRI
Expansion
</ins></a><ins class="diff-chg">
on
the
associated
value(s).
</ins>
</li>
<li>
Otherwise,
the
key
<em class="rfc2119" title="must">
must
</em>
have
the
lexical
form
of
<cite>
<a href="http://www.w3.org/TR/2009/REC-xml-names-20091208/#NT-NCName">
NCName
</a>
</cite>
and
<em class="rfc2119" title="must">
must
</em>
have
the
value
of
a
simple
string
with
the
lexical
form
of
IRI.
Merge
<del class="diff-old">each
</del>
<ins class="diff-chg">the
</ins>
key-value
pair
into
the
<del class="diff-old">active
</del>
<a class="tref internalDFN" title="local_context" href="#dfn-local_context">
<ins class="diff-chg">local
</ins>
context
<del class="diff-old">,
overwriting
any
duplicate
values.
</del>
</a>.
</li>
<del class="diff-old">A
</del>
</ol>
</li>
<li>
<ins class="diff-chg">Merge
the
of
</ins>
<a class="tref internalDFN" title="local_context" href="#dfn-local_context">
local
context
</a>
<del class="diff-old">may
also
be
loaded
from
an
external
document
using
</del>
<ins class="diff-chg">'s
</ins><code><ins class="diff-chg">
@coerce
</ins></code><ins class="diff-chg">
mapping
into
</ins>
the
<a class="tref internalDFN" title="active_context" href="#dfn-active_context">
<ins class="diff-new">active
context
</ins></a><ins class="diff-new">
's
</ins>
<code>
<del class="diff-old">@profile
</del>
<ins class="diff-chg">@coerce
</ins>
</code>
<del class="diff-old">key
</del>
<ins class="diff-chg">mapping
</ins>
as
described
<del class="diff-old">in
Vocabulary
Profiles
</del>
<a href="#coerce">
<ins class="diff-chg">below
</ins>
</a>.
</li>
<li>
<ins class="diff-chg">Merge
all
entries
other
than
the
</ins><code><ins class="diff-chg">
@coerce
</ins></code><ins class="diff-chg">
mapping
from
the
</ins><a class="tref internalDFN" title="local_context" href="#dfn-local_context"><ins class="diff-chg">
local
context
</ins></a><ins class="diff-chg">
to
the
</ins><a class="tref internalDFN" title="active_context" href="#dfn-active_context"><ins class="diff-chg">
active
context
</ins></a><ins class="diff-chg">
overwriting
any
duplicate
values.
</ins></li></ol>
<div id="coerce" class="section">
<h4>
<span class="secno">
<del class="diff-old">6.4.1
</del>
<ins class="diff-chg">5.3.1
</ins>
</span>
Coerce
</h4>
<p>
Map
each
key-value
pair
in
the
<a class="tref internalDFN" title="local_context" href="#dfn-local_context">
local
context
</a>
's
<code>
@coerce
</code>
mapping
into
the
<a class="tref internalDFN" title="active_context" href="#dfn-active_context">
active
context
</a>
's
<code>
@coerce
</code>
mapping,
overwriting
any
duplicate
values
in
the
<a class="tref internalDFN" title="active_context" href="#dfn-active_context">
active
context
</a>
's
<code>
@coerce
</code>
mapping.
The
<code>
@coerce
</code>
mapping
has
<del class="diff-old">a
</del>
either
<del class="diff-old">of
</del>
a
single
CURIE
or
<del class="diff-old">of
</del>
an
array
of
CURIEs.
When
merging
with
an
existing
mapping
in
the
<a class="tref internalDFN" title="active_context" href="#dfn-active_context">
active
context
</a>,
map
all
CURIE
values
to
array
form
and
replace
with
the
union
of
the
value
from
the
<a class="tref internalDFN" title="local_context" href="#dfn-local_context">
local
context
</a>
and
the
value
of
the
<a class="tref internalDFN" title="active_context" href="#dfn-active_context">
active
context
</a>.
If
the
result
is
an
array
with
a
single
CURIE,
the
processor
<em class="rfc2119" title="may">
may
</em>
represent
this
as
a
string
value.
</p>
</div>
<div id="initial-context" class="section">
<h4>
<span class="secno">
<del class="diff-old">6.5
</del>
<ins class="diff-chg">5.3.2
</ins>
</span>
<del class="diff-old">Chaining
</del>
<ins class="diff-chg">Initial
Context
</ins></h4>
<p>
<del class="diff-old">Object
chaining
</del>
<ins class="diff-chg">The
</ins><a class="tref internalDFN" title="initial_context" href="#dfn-initial_context"><ins class="diff-chg">
initial
context
</ins></a>
is
<del class="diff-old">a
JSON-LD
feature
that
allows
an
author
to
use
the
definition
of
JSON-LD
objects
</del>
<ins class="diff-chg">initialized
</ins>
as
<del class="diff-old">property
values.
This
</del>
<ins class="diff-chg">follows:
</ins></p><ul><li><code><ins class="diff-chg">
@base
</ins></code>
is
<ins class="diff-new">set
using
</ins><cite><href="http: www.ietf.org="" rfc="" rfc2396.txt"=""><ins class="diff-new">
section
5.1
Establishing
</ins>
a
<del class="diff-old">commonly
used
mechanism
for
creating
</del>
<ins class="diff-chg">Base
URI
</ins></href="http:></cite><ins class="diff-chg">
of
[
</ins><cite><a class="bibref" rel="biblioentry" href="#bib-RFC3986"><ins class="diff-chg">
RFC3986
</ins></a></cite><ins class="diff-chg">
].
Processors
</ins><em class="rfc2119" title="may"><ins class="diff-chg">
may
</ins></em><ins class="diff-chg">
provide
</ins>
a
<del class="diff-old">parent-child
relationship
between
objects.
The
example
shows
an
two
objects
related
by
</del>
<ins class="diff-chg">means
of
setting
the
base
IRI
programatically.
</ins></li><li><code><ins class="diff-chg">
@coerce
</ins></code><ins class="diff-chg">
is
set
with
</ins>
a
<del class="diff-old">property
</del>
<ins class="diff-chg">single
mapping
</ins>
from
<del class="diff-old">the
first
object:
  
</del>
<code>
<ins class="diff-chg">@iri
</ins></code><ins class="diff-chg">
to
</ins><code><ins class="diff-chg">
@type
</ins></code>.</li></ul>    <pre class="example">
{
<del class="diff-old">...
  "foaf:name": "Manu Sporny",
  "": {
    "",
    "",
  }
...
</del>
<ins class="diff-chg">    "@base": <span class="diff">document-location</span>,
    "@context": {
      "@iri": "@type"
    }
</ins>
}
</pre>
<del class="diff-old">An
object
definition
may
be
used
anyplace
a
value
is
legal
in
JSON-LD.
</del>
</div>
</div>
<div id="iri-expansion" class="section">
<h3>
<span class="secno">
<del class="diff-old">6.6
</del>
<ins class="diff-chg">5.4
</ins>
</span>
IRI
<del class="diff-old">Processing
</del>
<ins class="diff-chg">Expansion
</ins>
</h3>
<p>
Keys
and
some
values
are
evaluated
to
produce
an
IRI.
This
section
defines
an
algorithm
for
transforming
a
value
representing
an
IRI
into
an
actual
IRI.
</p>
<p>
IRIs
may
be
represented
as
an
explicit
string,
or
as
a
CURIE,
as
a
value
relative
to
<code>
@base
</code>
or
<code>
@vocab
</code>.
</p>
<p>
CURIEs
are
defined
more
formally
in
[
<cite>
<a class="bibref" rel="biblioentry" href="#bib-RDFA-CORE">
RDFA-CORE
</a>
</cite>
]
<cite>
<a href="http://www.w3.org/TR/rdfa-core/#s_curies">
section
6
"CURIE
Syntax
Definition"
</a>
</cite>.
Generally,
a
CURIE
is
composed
of
a
<em>
prefix
</em>
and
a
<em>
suffix
</em>
separated
by
a
':'.
In
JSON-LD,
either
the
prefix
may
be
the
empty
string,
denoting
the
<dfn title="default_prefix" id="dfn-default_prefix">
default
prefix
</dfn>.
</p>
<p>
The
<del class="diff-old">procedure
</del>
<ins class="diff-chg">algorithm
</ins>
for
generating
an
IRI
is:
</p>
<ol class="algorithm">
<li>
Split
the
value
into
a
<em>
prefix
</em>
and
<em>
suffix
</em>
from
the
first
occurrence
of
':'.
</li>
<li>
If
the
prefix
is
a
<del class="diff-old">'_',
generate
a
named
BNode
using
the
suffix
as
</del>
<ins class="diff-chg">'_'
(underscore),
</ins>
the
<del class="diff-old">name.
</del>
<ins class="diff-chg">IRI
is
unchanged.
</ins>
</li>
<li>
If
the
<a class="tref internalDFN" title="active_context" href="#dfn-active_context">
active
context
</a>
contains
a
mapping
for
<em>
prefix
</em>,
generate
an
IRI
by
prepending
the
mapped
prefix
to
the
(possibly
empty)
<del class="diff-old">suffix.
</del>
<ins class="diff-chg">suffix
using
textual
concatenation.
</ins>
Note
that
an
empty
suffix
and
no
suffix
(meaning
the
value
contains
no
':'
string
at
all)
are
treated
equivalently.
</li>
<li>
If
the
IRI
being
processed
is
for
a
property
(i.e.,
a
key
value
in
an
associative
array,
or
a
value
in
a
<code>
@coerce
</code>
mapping)
and
the
active
context
has
a
<code>
@vocab
</code>
mapping,
join
the
mapped
value
to
the
suffix
using
<del class="diff-old">the
method
described
in
[
RFC3987
].
</del>
<ins class="diff-chg">textual
concatenation.
</ins>
</li>
<li>
If
the
IRI
being
processed
is
for
a
subject
or
object
(i.e.,
not
a
property)
and
the
active
context
has
a
<code>
@base
</code>
mapping,
join
the
mapped
value
to
the
suffix
using
the
method
described
in
[
<cite>
<del class="diff-old">RFC3987
</del>
<a class="bibref" rel="biblioentry" href="#bib-RFC3986">
<ins class="diff-chg">RFC3986
</ins>
</a>
</cite>
].
</li>
<li>
Otherwise,
use
the
value
directly
as
an
IRI.
</li>
</ol>
<p>
</p>
</div>
<div id="iri-compaction" class="section">
<h3>
<span class="secno">
<ins class="diff-new">5.5
</ins></span><ins class="diff-new">
IRI
Compaction
</ins></h3><p><ins class="diff-new">
Some
keys
and
values
are
expressed
using
IRIs.
This
section
defines
an
algorithm
for
transforming
an
IRI
to
a
compact
IRI
using
the
</ins><a class="tref internalDFN" title="term" href="#dfn-term"><ins class="diff-new">
term
</ins></a><ins class="diff-new">
s
and
</ins><a class="tref internalDFN" title="prefix" href="#dfn-prefix"><ins class="diff-new">
prefix
</ins></a><ins class="diff-new">
es
specified
in
the
</ins><a class="tref internalDFN" title="local_context" href="#dfn-local_context"><ins class="diff-new">
local
context
</ins></a>.</p><p><ins class="diff-new">
The
algorithm
for
generating
a
compacted
IRI
is:
</ins></p><ol class="algorithm"><li><ins class="diff-new">
Search
every
key-value
pair
in
the
</ins><a class="tref internalDFN" title="active_context" href="#dfn-active_context"><ins class="diff-new">
active
context
</ins></a><ins class="diff-new">
for
a
</ins><a class="tref internalDFN" title="term" href="#dfn-term"><ins class="diff-new">
term
</ins></a><ins class="diff-new">
that
is
a
complete
match
against
the
IRI.
If
a
complete
match
is
found,
the
resulting
compacted
IRI
is
the
</ins><a class="tref internalDFN" title="term" href="#dfn-term"><ins class="diff-new">
term
</ins></a><ins class="diff-new">
associated
with
the
IRI
in
the
</ins><a class="tref internalDFN" title="active_context" href="#dfn-active_context"><ins class="diff-new">
active
context
</ins></a>.</li><li><ins class="diff-new">
If
a
complete
match
is
not
found,
search
for
a
partial
match
from
the
beginning
of
the
IRI.
For
all
matches
that
are
found,
the
resulting
compacted
IRI
is
the
</ins><a class="tref internalDFN" title="prefix" href="#dfn-prefix"><ins class="diff-new">
prefix
</ins></a><ins class="diff-new">
associated
with
the
partially
matched
IRI
in
the
</ins><a class="tref internalDFN" title="active_context" href="#dfn-active_context"><ins class="diff-new">
active
context
</ins></a><ins class="diff-new">
concatenated
with
a
colon
(:)
character
and
the
unmatched
part
of
the
string.
If
there
is
more
than
one
compacted
IRI
produced,
the
final
value
is
the
lexicographically
least
value
of
the
entire
set
of
compacted
IRIs.
</ins></li></ol><p></p>
</div>
<div id="value-expansion" class="section">
<h3>
<span class="secno">
<del class="diff-old">7.
</del>
<ins class="diff-chg">5.6
</ins>
</span>
<del class="diff-old">Sequence
</del>
<ins class="diff-chg">Value
Expansion
</ins></h3><p><ins class="diff-chg">
Some
values
in
JSON-LD
can
be
expressed
in
a
compact
form.
These
values
are
required
to
be
expanded
at
times
when
processing
JSON-LD
documents.
</ins></p><p><ins class="diff-chg">
The
algorithm
for
expanding
a
value
is:
</ins></p><ol class="algorithm"><li><ins class="diff-chg">
If
the
key
that
is
associated
with
the
value
has
an
associated
coercion
entry
in
the
</ins><a class="tref internalDFN" title="local_context" href="#dfn-local_context"><ins class="diff-chg">
local
context
</ins></a>,<ins class="diff-chg">
the
resulting
expansion
is
an
object
populated
according
to
the
following
steps:
</ins><ol class="algorithm"><li><ins class="diff-chg">
If
the
coercion
target
is
</ins><code><ins class="diff-chg">
@iri
</ins></code>,<ins class="diff-chg">
expand
the
value
by
adding
a
new
key-value
pair
where
the
key
is
</ins><code><ins class="diff-chg">
@iri
</ins></code><ins class="diff-chg">
and
the
value
is
the
expanded
IRI
according
to
the
</ins><a href="#iri-expansion"><ins class="diff-chg">
IRI
Expansion
</ins></a><ins class="diff-chg">
rules.
</ins></li><li><ins class="diff-chg">
If
the
coercion
target
is
a
typed
literal,
expand
the
value
by
adding
two
new
key-value
pairs.
The
first
key-value
pair
will
be
</ins><code><ins class="diff-chg">
@literal
</ins></code><ins class="diff-chg">
and
the
unexpanded
value.
The
second
key-value
pair
will
be
</ins><code><ins class="diff-chg">
@datatype
</ins></code><ins class="diff-chg">
and
the
associated
coercion
datatype
expanded
according
to
the
</ins><a href="#iri-expansion"><ins class="diff-chg">
IRI
Expansion
</ins></a><ins class="diff-chg">
rules.
</ins></li></ol></li></ol><p></p></div><div id="value-compaction" class="section"><h3><span class="secno"><ins class="diff-chg">
5.7
</ins></span><ins class="diff-chg">
Value
Compaction
</ins></h3><p><ins class="diff-chg">
Some
values,
such
as
IRIs
and
typed
literals,
may
be
expressed
in
an
expanded
form
in
JSON-LD.
These
values
are
required
to
be
compacted
at
times
when
processing
JSON-LD
documents.
</ins></p><p><ins class="diff-chg">
The
algorithm
for
compacting
a
value
is:
</ins></p><ol class="algorithm"><li><ins class="diff-chg">
If
the
</ins><a class="tref internalDFN" title="local_context" href="#dfn-local_context"><ins class="diff-chg">
local
context
</ins></a><ins class="diff-chg">
contains
a
coercion
target
for
the
key
that
is
associated
with
the
value,
compact
the
value
using
the
following
steps:
</ins><ol class="algorithm"><li><ins class="diff-chg">
If
the
coercion
target
is
an
</ins><code><ins class="diff-chg">
@iri
</ins></code>,<ins class="diff-chg">
the
compacted
value
is
the
value
associated
with
the
</ins><code><ins class="diff-chg">
@iri
</ins></code><ins class="diff-chg">
key,
processed
according
to
the
</ins><a href="#iri-compaction"><ins class="diff-chg">
IRI
Compaction
</ins></a><ins class="diff-chg">
steps.
</ins></li><li><ins class="diff-chg">
If
the
coercion
target
is
a
typed
literal,
the
compacted
value
is
the
value
associated
with
the
</ins><code><ins class="diff-chg">
@literal
</ins></code><ins class="diff-chg">
key.
</ins></li><li><ins class="diff-chg">
Otherwise,
the
value
is
not
modified.
</ins></li></ol></li></ol><p></p></div><div id="expansion-1" class="section"><h3><span class="secno"><ins class="diff-chg">
5.8
</ins></span><ins class="diff-chg">
Expansion
</ins></h3><p class="issue"><ins class="diff-chg">
This
algorithm
is
a
work
in
progress,
do
not
implement
it.
</ins></p><p><ins class="diff-chg">
As
stated
previously,
expansion
is
the
process
of
taking
a
JSON-LD
input
and
expanding
all
IRIs
and
typed
literals
to
their
fully-expanded
form.
The
output
will
not
contain
a
single
context
declaration
and
will
have
all
IRIs
and
typed
literals
fully
expanded.
</ins></p><div id="expansion-algorithm" class="section"><h4><span class="secno"><ins class="diff-chg">
5.8.1
</ins></span><ins class="diff-chg">
Expansion
Algorithm
</ins></h4><ol class="algorithm"><li><ins class="diff-chg">
If
the
top-level
item
in
the
</ins><a class="tref internalDFN" title="JSON-LD_input" href="#dfn-json-ld_input"><ins class="diff-chg">
JSON-LD
input
</ins></a><ins class="diff-chg">
is
an
array,
process
each
item
in
the
array
recursively
using
this
algorithm.
</ins></li><li><ins class="diff-chg">
If
the
top-level
item
in
the
</ins><a class="tref internalDFN" title="JSON-LD_input" href="#dfn-json-ld_input"><ins class="diff-chg">
JSON-LD
input
</ins></a><ins class="diff-chg">
is
an
object,
update
the
</ins><a class="tref internalDFN" title="local_context" href="#dfn-local_context"><ins class="diff-chg">
local
context
</ins></a><ins class="diff-chg">
according
to
the
steps
outlined
in
the
</ins><a href="#context"><ins class="diff-chg">
context
</ins></a><ins class="diff-chg">
section.
Process
each
key,
expanding
the
key
according
to
the
</ins><a href="#iri-expansion"><ins class="diff-chg">
IRI
Expansion
</ins></a><ins class="diff-chg">
rules.
</ins></li><ol class="algorithm"><li><ins class="diff-chg">
Process
each
value
associated
with
each
key
</ins><ol class="algorithm"><li><ins class="diff-chg">
If
the
value
is
an
array,
process
each
item
in
the
array
recursively
using
this
algorithm.
</ins></li><li><ins class="diff-chg">
If
the
value
is
an
object,
process
the
object
recursively
using
this
algorithm.
</ins></li><li><ins class="diff-chg">
Otherwise,
check
to
see
the
associated
key
has
an
associated
coercion
rule.
If
the
value
should
be
coerced,
expand
the
value
according
to
the
</ins><a href="#value-expansion"><ins class="diff-chg">
Value
Expansion
</ins></a><ins class="diff-chg">
rules.
If
the
value
does
not
need
to
be
coerced,
leave
the
value
as-is.
</ins></li></ol></li><li><ins class="diff-chg">
Remove
the
context
from
the
object
</ins></li></ol></ol></div></div><div id="compaction-1" class="section"><h3><span class="secno"><ins class="diff-chg">
5.9
</ins></span><ins class="diff-chg">
Compaction
</ins></h3><p class="issue"><ins class="diff-chg">
This
algorithm
is
a
work
in
progress,
do
not
implement
it.
</ins></p><p><ins class="diff-chg">
As
stated
previously,
compaction
is
the
process
of
taking
a
JSON-LD
input
and
compacting
all
IRIs
using
a
given
context.
The
output
will
contain
a
single
top-level
context
declaration
and
will
only
use
</ins><a class="tref internalDFN" title="term" href="#dfn-term"><ins class="diff-chg">
term
</ins></a><ins class="diff-chg">
s
and
</ins><a class="tref internalDFN" title="prefix" href="#dfn-prefix"><ins class="diff-chg">
prefix
</ins></a><ins class="diff-chg">
es
and
will
ensure
that
all
typed
literals
are
fully
compacted.
</ins></p><div id="compaction-algorithm" class="section"><h4><span class="secno"><ins class="diff-chg">
5.9.1
</ins></span><ins class="diff-chg">
Compaction
Algorithm
</ins></h4><ol class="algorithm"><li><ins class="diff-chg">
Perform
the
</ins><a href="#expansion-algorithm"><ins class="diff-chg">
Expansion
Algorithm
</ins></a><ins class="diff-chg">
on
the
</ins><a class="tref internalDFN" title="JSON-LD_input" href="#dfn-json-ld_input"><ins class="diff-chg">
JSON-LD
input
</ins></a>.</li><li><ins class="diff-chg">
If
the
top-level
item
is
an
array,
process
each
item
in
the
array
recursively,
starting
at
this
step.
</ins></li><li><ins class="diff-chg">
If
the
top-level
item
is
an
object,
compress
each
key
using
the
steps
defined
in
</ins><a href="#iri-compaction"><ins class="diff-chg">
IRI
Compaction
</ins></a><ins class="diff-chg">
and
compress
each
value
using
the
steps
defined
in
</ins><a href="#value-compaction"><ins class="diff-chg">
Value
Compaction
</ins></a></li></ol></div></div><div id="framing-1" class="section"><h3><span class="secno"><ins class="diff-chg">
5.10
</ins></span><ins class="diff-chg">
Framing
</ins></h3><p class="issue"><ins class="diff-chg">
This
algorithm
is
a
work
in
progress,
do
not
implement
it.
</ins></p><p><ins class="diff-chg">
A
JSON-LD
document
is
a
representation
of
a
directed
graph.
A
single
directed
graph
can
have
many
different
serializations,
each
expressing
exactly
the
same
information.
Developers
typically
don't
work
directly
with
graphs,
but
rather,
prefer
trees
when
dealing
with
JSON.
While
mapping
a
graph
to
a
tree
can
be
done,
the
layout
of
the
end
result
must
be
specified
in
advance.
This
section
defines
an
algorithm
for
mapping
a
graph
to
a
tree
given
a
</ins><a class="tref internalDFN" title="frame" href="#dfn-frame"><ins class="diff-chg">
frame
</ins></a>.</p><div id="framing-algorithm-terms" class="section"><h4><span class="secno"><ins class="diff-chg">
5.10.1
</ins></span><ins class="diff-chg">
Framing
Algorithm
Terms
</ins></h4><dl><dt><dfn title="input_frame" id="dfn-input_frame"><ins class="diff-chg">
input
frame
</ins></dfn></dt><dd><ins class="diff-chg">
the
initial
</ins><a class="tref internalDFN" title="frame" href="#dfn-frame"><ins class="diff-chg">
frame
</ins></a><ins class="diff-chg">
provided
to
the
framing
algorithm.
</ins></dd><dt><dfn title="framing_context" id="dfn-framing_context"><ins class="diff-chg">
framing
context
</ins></dfn></dt><dd><ins class="diff-chg">
a
context
containing
the
</ins><a class="tref internalDFN" title="object_embed_flag" href="#dfn-object_embed_flag"><ins class="diff-chg">
object
embed
flag
</ins></a>,<ins class="diff-chg">
the
</ins><a class="tref internalDFN" title="explicit_inclusion_flag" href="#dfn-explicit_inclusion_flag"><ins class="diff-chg">
explicit
inclusion
flag
</ins></a><ins class="diff-chg">
and
the
</ins><a class="tref" title="omit_default_flag"><ins class="diff-chg">
omit
default
flag
</ins></a>.</dd><dt><dfn title="object_embed_flag" id="dfn-object_embed_flag"><ins class="diff-chg">
object
embed
flag
</ins></dfn></dt><dd><ins class="diff-chg">
a
flag
specifying
that
objects
should
be
directly
embedded
in
the
output,
instead
of
being
referred
to
by
their
IRI.
</ins></dd><dt><dfn title="explicit_inclusion_flag" id="dfn-explicit_inclusion_flag"><ins class="diff-chg">
explicit
inclusion
flag
</ins></dfn></dt><dd><ins class="diff-chg">
a
flag
specifying
that
for
properties
to
be
included
in
the
output,
they
must
be
explicitly
declared
in
the
</ins><a class="tref internalDFN" title="framing_context" href="#dfn-framing_context"><ins class="diff-chg">
framing
context
</ins></a>.</dd><dt><dfn title="omit_missing_properties_flag" id="dfn-omit_missing_properties_flag"><ins class="diff-chg">
omit
missing
properties
flag
</ins></dfn></dt><dd><ins class="diff-chg">
a
flag
specifying
that
properties
that
are
missing
from
the
</ins><a class="tref internalDFN" title="JSON-LD_input" href="#dfn-json-ld_input"><ins class="diff-chg">
JSON-LD
input
</ins></a><ins class="diff-chg">
should
be
omitted
from
the
output.
</ins></dd><dt><dfn title="match_limit" id="dfn-match_limit"><ins class="diff-chg">
match
limit
</ins></dfn></dt><dd><ins class="diff-chg">
A
value
specifying
the
maximum
number
of
matches
to
accept
when
building
arrays
of
values
during
the
framing
algorithm.
A
value
of
-1
specifies
that
there
is
no
match
limit.
</ins></dd><dt><dfn title="map_of_embedded_subjects" id="dfn-map_of_embedded_subjects"><ins class="diff-chg">
map
of
embedded
subjects
</ins></dfn></dt><dd><ins class="diff-chg">
A
map
that
tracks
if
a
subject
has
been
embedded
in
the
output
of
the
</ins><a href="#framing-algorithm"><ins class="diff-chg">
Framing
Algorithm
</ins></a>.</dd></dl></div><div id="framing-algorithm" class="section"><h4><span class="secno"><ins class="diff-chg">
5.10.2
</ins></span><ins class="diff-chg">
Framing
Algorithm
</ins></h4><p><ins class="diff-chg">
The
framing
algorithm
takes
</ins><a class="tref internalDFN" title="JSON-LD_input" href="#dfn-json-ld_input"><ins class="diff-chg">
JSON-LD
input
</ins></a><ins class="diff-chg">
that
has
been
normalized
according
to
the
</ins><a href="#normalization-algorithm"><ins class="diff-chg">
Normalization
Algorithm
</ins></a><ins class="diff-chg">
(
</ins><strong><ins class="diff-chg">
normalized
input
</ins></strong><ins class="diff-chg">
),
an
</ins><a class="tref internalDFN" title="input_frame" href="#dfn-input_frame"><ins class="diff-chg">
input
frame
</ins></a><ins class="diff-chg">
that
has
been
expanded
according
to
the
</ins><a href="#expansion-algorithm"><ins class="diff-chg">
Expansion
Algorithm
</ins></a><ins class="diff-chg">
(
</ins><strong><ins class="diff-chg">
expanded
frame
</ins></strong><ins class="diff-chg">
),
and
a
number
of
options
and
produces
</ins><a class="tref internalDFN" title="JSON-LD_output" href="#dfn-json-ld_output"><ins class="diff-chg">
JSON-LD
output
</ins></a>.<ins class="diff-chg">
The
following
series
of
steps
is
the
recursive
portion
of
the
framing
algorithm:
</ins></p><ol class="algorithm"><li><ins class="diff-chg">
Initialize
the
</ins><a class="tref internalDFN" title="framing_context" href="#dfn-framing_context"><ins class="diff-chg">
framing
context
</ins></a><ins class="diff-chg">
by
setting
the
</ins><a class="tref internalDFN" title="object_embed_flag" href="#dfn-object_embed_flag"><ins class="diff-chg">
object
embed
flag
</ins></a>,<ins class="diff-chg">
clearing
the
</ins><a class="tref internalDFN" title="explicit_inclusion_flag" href="#dfn-explicit_inclusion_flag"><ins class="diff-chg">
explicit
inclusion
flag
</ins></a>,<ins class="diff-chg">
and
clearing
the
</ins><a class="tref internalDFN" title="omit_missing_properties_flag" href="#dfn-omit_missing_properties_flag"><ins class="diff-chg">
omit
missing
properties
flag
</ins></a>.<ins class="diff-chg">
Override
these
values
based
on
input
options
provided
to
the
algorithm
by
the
application.
</ins></li><li><ins class="diff-chg">
Generate
a
</ins><dfn title="list_of_frames" id="dfn-list_of_frames"><ins class="diff-chg">
list
of
frames
</ins></dfn><ins class="diff-chg">
by
processing
the
</ins><strong><ins class="diff-chg">
expanded
frame
</ins></strong>:<ol class="algorithm"><li><ins class="diff-chg">
If
the
</ins><strong><ins class="diff-chg">
expanded
frame
</ins></strong><ins class="diff-chg">
is
not
an
array,
set
</ins><a class="tref internalDFN" title="match_limit" href="#dfn-match_limit"><ins class="diff-chg">
match
limit
</ins></a><ins class="diff-chg">
to
1,
place
the
</ins><strong><ins class="diff-chg">
expanded
frame
</ins></strong><ins class="diff-chg">
into
the
</ins><a class="tref internalDFN" title="list_of_frames" href="#dfn-list_of_frames"><ins class="diff-chg">
list
of
frames
</ins></a>,<ins class="diff-chg">
and
set
the
</ins><a class="tref internalDFN" title="JSON-LD_output" href="#dfn-json-ld_output"><ins class="diff-chg">
JSON-LD
output
</ins></a><ins class="diff-chg">
to
</ins><code><ins class="diff-chg">
null
</ins></code>.</li><li><ins class="diff-chg">
If
the
</ins><strong><ins class="diff-chg">
expanded
frame
</ins></strong><ins class="diff-chg">
is
an
empty
array,
place
an
empty
object
into
the
</ins><a class="tref internalDFN" title="list_of_frames" href="#dfn-list_of_frames"><ins class="diff-chg">
list
of
frames
</ins></a>,<ins class="diff-chg">
set
the
</ins><a class="tref internalDFN" title="JSON-LD_output" href="#dfn-json-ld_output"><ins class="diff-chg">
JSON-LD
output
</ins></a><ins class="diff-chg">
to
an
array,
and
set
</ins><a class="tref internalDFN" title="match_limit" href="#dfn-match_limit"><ins class="diff-chg">
match
limit
</ins></a><ins class="diff-chg">
to
-1.
</ins></li><li><ins class="diff-chg">
If
the
</ins><strong><ins class="diff-chg">
expanded
frame
</ins></strong><ins class="diff-chg">
is
a
non-empty
array,
add
each
item
in
the
</ins><strong><ins class="diff-chg">
expanded
frame
</ins></strong><ins class="diff-chg">
into
the
</ins><a class="tref internalDFN" title="list_of_frames" href="#dfn-list_of_frames"><ins class="diff-chg">
list
of
frames
</ins></a>,<ins class="diff-chg">
set
the
</ins><a class="tref internalDFN" title="JSON-LD_output" href="#dfn-json-ld_output"><ins class="diff-chg">
JSON-LD
output
</ins></a><ins class="diff-chg">
to
an
array,
and
set
</ins><a class="tref internalDFN" title="match_limit" href="#dfn-match_limit"><ins class="diff-chg">
match
limit
</ins></a><ins class="diff-chg">
to
-1.
</ins></li></ol></li><li><ins class="diff-chg">
Create
a
</ins><dfn title="match_array" id="dfn-match_array"><ins class="diff-chg">
match
array
</ins></dfn><ins class="diff-chg">
for
each
</ins><strong><ins class="diff-chg">
expanded
frame
</ins></strong><ins class="diff-chg">
in
the
</ins><a class="tref internalDFN" title="list_of_frames" href="#dfn-list_of_frames"><ins class="diff-chg">
list
of
frames
</ins></a><ins class="diff-chg">
halting
when
either
the
</ins><a class="tref internalDFN" title="match_limit" href="#dfn-match_limit"><ins class="diff-chg">
match
limit
</ins></a><ins class="diff-chg">
is
zero
or
the
end
of
the
</ins><a class="tref internalDFN" title="list_of_frames" href="#dfn-list_of_frames"><ins class="diff-chg">
list
of
frames
</ins></a><ins class="diff-chg">
is
reached.
If
an
</ins><strong><ins class="diff-chg">
expanded
frame
</ins></strong><ins class="diff-chg">
is
not
an
object,
the
processor
</ins><em class="rfc2119" title="must"><ins class="diff-chg">
must
</ins></em><ins class="diff-chg">
throw
a
</ins><code><ins class="diff-chg">
Invalid
Frame
Format
</ins></code><ins class="diff-chg">
exception.
Add
each
matching
item
from
the
</ins><strong><ins class="diff-chg">
normalized
input
</ins></strong><ins class="diff-chg">
to
the
</ins><a class="tref" title="matches_array"><ins class="diff-chg">
matches
array
</ins></a><ins class="diff-chg">
and
decrement
the
</ins><a class="tref internalDFN" title="match_limit" href="#dfn-match_limit"><ins class="diff-chg">
match
limit
</ins></a><ins class="diff-chg">
by
1
if:
</ins><ol class="algorithm"><li><ins class="diff-chg">
The
</ins><strong><ins class="diff-chg">
expanded
frame
</ins></strong><ins class="diff-chg">
has
an
</ins><code><ins class="diff-chg">
rdf:type
</ins></code><ins class="diff-chg">
that
exists
in
the
item's
list
of
</ins><code><ins class="diff-chg">
rdf:type
</ins></code><ins class="diff-chg">
s.
Note:
the
</ins><code><ins class="diff-chg">
rdf:type
</ins></code><ins class="diff-chg">
can
be
an
array,
but
only
one
value
needs
to
be
in
common
between
the
item
and
the
</ins><strong><ins class="diff-chg">
expanded
frame
</ins></strong><ins class="diff-chg">
for
a
match.
</ins></li><li><ins class="diff-chg">
The
</ins><strong><ins class="diff-chg">
expanded
frame
</ins></strong><ins class="diff-chg">
does
not
have
an
</ins><code><ins class="diff-chg">
rdf:type
</ins></code><ins class="diff-chg">
property,
but
every
property
in
the
</ins><strong><ins class="diff-chg">
expanded
frame
</ins></strong><ins class="diff-chg">
exists
in
the
item.
</ins></li></ol></li><li><ins class="diff-chg">
Process
each
item
in
the
</ins><a class="tref internalDFN" title="match_array" href="#dfn-match_array"><ins class="diff-chg">
match
array
</ins></a><ins class="diff-chg">
with
its
associated
</ins><dfn title="match_frame" id="dfn-match_frame"><ins class="diff-chg">
match
frame
</ins></dfn>:<ol class="algorithm"><li><ins class="diff-chg">
If
the
</ins><a class="tref internalDFN" title="match_frame" href="#dfn-match_frame"><ins class="diff-chg">
match
frame
</ins></a><ins class="diff-chg">
contains
an
</ins><code><ins class="diff-chg">
@embed
</ins></code><ins class="diff-chg">
keyword,
set
the
</ins><a class="tref internalDFN" title="object_embed_flag" href="#dfn-object_embed_flag"><ins class="diff-chg">
object
embed
flag
</ins></a><ins class="diff-chg">
to
its
value.
If
the
</ins><a class="tref internalDFN" title="match_frame" href="#dfn-match_frame"><ins class="diff-chg">
match
frame
</ins></a><ins class="diff-chg">
contains
an
</ins><code><ins class="diff-chg">
@explicit
</ins></code><ins class="diff-chg">
keyword,
set
the
</ins><a class="tref internalDFN" title="explicit_inclusion_flag" href="#dfn-explicit_inclusion_flag"><ins class="diff-chg">
explicit
inclusion
flag
</ins></a><ins class="diff-chg">
to
its
value.
Note:
if
the
keyword
exists,
but
the
value
is
neither
</ins><code><ins class="diff-chg">
true
</ins></code><ins class="diff-chg">
or
</ins><code><ins class="diff-chg">
false
</ins></code>,<ins class="diff-chg">
set
the
associated
flag
to
</ins><code><ins class="diff-chg">
true
</ins></code>.</li><li><ins class="diff-chg">
If
the
</ins><a class="tref internalDFN" title="object_embed_flag" href="#dfn-object_embed_flag"><ins class="diff-chg">
object
embed
flag
</ins></a><ins class="diff-chg">
is
cleared
and
the
item
has
the
</ins><code><ins class="diff-chg">
@subject
</ins></code><ins class="diff-chg">
property,
replace
the
item
with
the
value
of
the
</ins><code><ins class="diff-chg">
@subject
</ins></code><ins class="diff-chg">
property.
</ins></li><li><ins class="diff-chg">
If
the
</ins><a class="tref internalDFN" title="object_embed_flag" href="#dfn-object_embed_flag"><ins class="diff-chg">
object
embed
flag
</ins></a><ins class="diff-chg">
is
set
and
the
item
has
the
</ins><code><ins class="diff-chg">
@subject
</ins></code><ins class="diff-chg">
property,
and
its
IRI
is
in
the
</ins><a class="tref internalDFN" title="map_of_embedded_subjects" href="#dfn-map_of_embedded_subjects"><ins class="diff-chg">
map
of
embedded
subjects
</ins></a>,<ins class="diff-chg">
throw
a
</ins><code><ins class="diff-chg">
Duplicate
Embed
</ins></code><ins class="diff-chg">
exception.
</ins></li><li><ins class="diff-chg">
If
the
</ins><a class="tref internalDFN" title="object_embed_flag" href="#dfn-object_embed_flag"><ins class="diff-chg">
object
embed
flag
</ins></a><ins class="diff-chg">
is
set
and
the
item
has
the
</ins><code><ins class="diff-chg">
@subject
</ins></code><ins class="diff-chg">
property
and
its
IRI
is
not
in
the
</ins><a class="tref internalDFN" title="map_of_embedded_subjects" href="#dfn-map_of_embedded_subjects"><ins class="diff-chg">
map
of
embedded
subjects
</ins></a>:<ol class="algorithm"><li><ins class="diff-chg">
If
the
</ins><a class="tref internalDFN" title="explicit_inclusion_flag" href="#dfn-explicit_inclusion_flag"><ins class="diff-chg">
explicit
inclusion
flag
</ins></a><ins class="diff-chg">
is
set,
then
delete
any
key
from
the
item
that
does
not
exist
in
the
</ins><a class="tref internalDFN" title="match_frame" href="#dfn-match_frame"><ins class="diff-chg">
match
frame
</ins></a>,<ins class="diff-chg">
except
</ins><code><ins class="diff-chg">
@subject
</ins></code>.</li><li><ins class="diff-chg">
For
each
key
in
the
</ins><a class="tref internalDFN" title="match_frame" href="#dfn-match_frame"><ins class="diff-chg">
match
frame
</ins></a>,<ins class="diff-chg">
except
for
keywords
and
</ins><code><ins class="diff-chg">
rdf:type
</ins></code>:<ol class="algorithm"><li><ins class="diff-chg">
If
the
key
is
in
the
item,
then
build
a
new
</ins><dfn title="recursion_input_list" id="dfn-recursion_input_list"><ins class="diff-chg">
recursion
input
list
</ins></dfn><ins class="diff-chg">
using
the
object
or
objects
associated
with
the
key.
If
any
object
contains
an
</ins><code><ins class="diff-chg">
@iri
</ins></code><ins class="diff-chg">
value
that
exists
in
the
</ins><a class="tref" title="normalized_input"><ins class="diff-chg">
normalized
input
</ins></a>,<ins class="diff-chg">
replace
the
object
in
the
</ins><a class="tref" title="recusion_input_list"><ins class="diff-chg">
recusion
input
list
</ins></a><ins class="diff-chg">
with
a
new
object
containing
the
</ins><code><ins class="diff-chg">
@subject
</ins></code><ins class="diff-chg">
key
where
the
value
is
the
value
of
the
</ins><code><ins class="diff-chg">
@iri
</ins></code>,<ins class="diff-chg">
and
all
of
the
other
key-value
pairs
for
that
subject.
Set
the
</ins><dfn title="recursion_match_frame" id="dfn-recursion_match_frame"><ins class="diff-chg">
recursion
match
frame
</ins></dfn><ins class="diff-chg">
to
the
value
associated
with
the
</ins><a class="tref internalDFN" title="match_frame" href="#dfn-match_frame"><ins class="diff-chg">
match
frame
</ins></a><ins class="diff-chg">
's
key.
Replace
the
value
associated
with
the
key
by
recursively
calling
this
algorithm
using
</ins><a class="tref internalDFN" title="recursion_input_list" href="#dfn-recursion_input_list"><ins class="diff-chg">
recursion
input
list
</ins></a>,<a class="tref internalDFN" title="recursion_match_frame" href="#dfn-recursion_match_frame"><ins class="diff-chg">
recursion
match
frame
</ins></a><ins class="diff-chg">
as
input.
</ins></li><li><ins class="diff-chg">
If
the
key
is
not
in
the
item,
add
the
key
to
the
item
and
set
the
associated
value
to
an
empty
array
if
the
</ins><a class="tref internalDFN" title="match_frame" href="#dfn-match_frame"><ins class="diff-chg">
match
frame
</ins></a><ins class="diff-chg">
key's
value
is
an
array
or
</ins><code><ins class="diff-chg">
null
</ins></code><ins class="diff-chg">
otherwise.
</ins></li><li><ins class="diff-chg">
If
value
associated
with
the
item's
key
is
</ins><code><ins class="diff-chg">
null
</ins></code>,<ins class="diff-chg">
process
the
</ins><a class="tref internalDFN" title="omit_missing_properties_flag" href="#dfn-omit_missing_properties_flag"><ins class="diff-chg">
omit
missing
properties
flag
</ins></a>:<ol class="algorithm"><li><ins class="diff-chg">
If
the
value
associated
with
the
key
in
the
</ins><a class="tref internalDFN" title="match_frame" href="#dfn-match_frame"><ins class="diff-chg">
match
frame
</ins></a><ins class="diff-chg">
is
an
array,
use
the
first
frame
from
the
array
as
the
</ins><dfn title="property_frame" id="dfn-property_frame"><ins class="diff-chg">
property
frame
</ins></dfn>,<ins class="diff-chg">
otherwise
set
the
</ins><a class="tref internalDFN" title="property_frame" href="#dfn-property_frame"><ins class="diff-chg">
property
frame
</ins></a><ins class="diff-chg">
to
an
empty
object.
</ins></li><li><ins class="diff-chg">
If
the
</ins><a class="tref internalDFN" title="property_frame" href="#dfn-property_frame"><ins class="diff-chg">
property
frame
</ins></a><ins class="diff-chg">
contains
an
</ins><code><ins class="diff-chg">
@omitDefault
</ins></code><ins class="diff-chg">
keyword,
set
the
</ins><a class="tref internalDFN" title="omit_missing_properties_flag" href="#dfn-omit_missing_properties_flag"><ins class="diff-chg">
omit
missing
properties
flag
</ins></a><ins class="diff-chg">
to
its
value.
Note:
if
the
keyword
exists,
but
the
value
is
neither
</ins><code><ins class="diff-chg">
true
</ins></code><ins class="diff-chg">
or
</ins><code><ins class="diff-chg">
false
</ins></code>,<ins class="diff-chg">
set
the
associated
flag
to
</ins><code><ins class="diff-chg">
true
</ins></code>.</li><li><ins class="diff-chg">
If
the
</ins><a class="tref internalDFN" title="omit_missing_properties_flag" href="#dfn-omit_missing_properties_flag"><ins class="diff-chg">
omit
missing
properties
flag
</ins></a><ins class="diff-chg">
is
set,
delete
the
key
in
the
item.
Otherwise,
if
the
</ins><code><ins class="diff-chg">
@default
</ins></code><ins class="diff-chg">
keyword
is
set
in
the
</ins><a class="tref internalDFN" title="property_frame" href="#dfn-property_frame"><ins class="diff-chg">
property
frame
</ins></a><ins class="diff-chg">
set
the
item's
value
to
the
value
of
</ins><code><ins class="diff-chg">
@default
</ins></code>.</li></ol></li></ol></li></ol></li><li><ins class="diff-chg">
If
the
</ins><a class="tref internalDFN" title="JSON-LD_output" href="#dfn-json-ld_output"><ins class="diff-chg">
JSON-LD
output
</ins></a><ins class="diff-chg">
is
</ins><code><ins class="diff-chg">
null
</ins></code><ins class="diff-chg">
set
it
to
the
item,
otherwise,
append
the
item
to
the
</ins><a class="tref internalDFN" title="JSON-LD_output" href="#dfn-json-ld_output"><ins class="diff-chg">
JSON-LD
output
</ins></a>.</li></ol></li><li><ins class="diff-chg">
Return
the
</ins><a class="tref internalDFN" title="JSON-LD_output" href="#dfn-json-ld_output"><ins class="diff-chg">
JSON-LD
output
</ins></a>.</li></ol><ins class="diff-chg">
The
final,
non-recursive
step
of
the
framing
algorithm
requires
the
</ins><a class="tref internalDFN" title="JSON-LD_output" href="#dfn-json-ld_output"><ins class="diff-chg">
JSON-LD
output
</ins></a><ins class="diff-chg">
to
be
compacted
according
to
the
</ins><a href="#compaction-algorithm"><ins class="diff-chg">
Compaction
Algorithm
</ins></a><ins class="diff-chg">
by
using
the
context
provided
in
the
</ins><a class="tref internalDFN" title="input_frame" href="#dfn-input_frame"><ins class="diff-chg">
input
frame
</ins></a>.<ins class="diff-chg">
The
resulting
value
is
the
final
output
of
the
compaction
algorithm
and
is
what
should
be
returned
to
the
application.
</ins></div></div><div id="normalization-1" class="section"><h3><span class="secno"><ins class="diff-chg">
5.11
</ins></span><ins class="diff-chg">
Normalization
</ins></h3><p class="issue"><ins class="diff-chg">
This
algorithm
is
a
work
in
progress,
do
not
implement
it.
</ins></p><p><ins class="diff-chg">
Normalization
is
the
process
of
taking
</ins><a class="tref internalDFN" title="JSON-LD_input" href="#dfn-json-ld_input"><ins class="diff-chg">
JSON-LD
input
</ins></a><ins class="diff-chg">
and
performing
a
deterministic
transformation
on
that
input
that
results
in
all
aspects
of
the
graph
being
fully
expanded
and
named
in
the
</ins><a class="tref internalDFN" title="JSON-LD_output" href="#dfn-json-ld_output"><ins class="diff-chg">
JSON-LD
output
</ins></a>.<ins class="diff-chg">
The
normalized
output
is
generated
in
such
a
way
that
any
conforming
JSON-LD
processor
will
generate
identical
output
given
the
same
input.
The
problem
is
a
fairly
difficult
technical
problem
to
solve
because
it
requires
a
directed
graph
to
be
ordered
into
a
set
of
nodes
and
edges
in
a
deterministic
way.
This
is
easy
to
do
when
all
of
the
nodes
have
unique
names,
but
very
difficult
to
do
when
some
of
the
nodes
are
not
labeled.
</ins></p><p><ins class="diff-chg">
In
time,
there
may
be
more
than
one
normalization
algorithm
that
will
need
to
be
identified.
For
identification
purposes,
this
algorithm
is
named
</ins><abbr title="Universal Graph Normalization Algorithm 2011"><ins class="diff-chg">
UGNA2011
</ins></abbr>.</p><div id="normalization-algorithm-terms" class="section"><h4><span class="secno"><ins class="diff-chg">
5.11.1
</ins></span><ins class="diff-chg">
Normalization
Algorithm
Terms
</ins></h4><dl><dt><dfn title="list_of_expanded_nodes" id="dfn-list_of_expanded_nodes"><ins class="diff-chg">
list
of
expanded
nodes
</ins></dfn></dt><dd><ins class="diff-chg">
A
list
of
all
nodes
in
the
</ins><a class="tref internalDFN" title="JSON-LD_input" href="#dfn-json-ld_input"><ins class="diff-chg">
JSON-LD
input
</ins></a><ins class="diff-chg">
graph
containing
no
embedded
objects
and
having
all
keys
and
values
expanded
according
to
the
steps
in
the
</ins><a href="#expansion-algorithm"><ins class="diff-chg">
Expansion
Algorithm
</ins></a>.</dd><dt><dfn title="naming_base_string" id="dfn-naming_base_string"><ins class="diff-chg">
naming
base
string
</ins></dfn></dt><dd><ins class="diff-chg">
An
unlabeled
node
naming
prefix
that
is
not
used
by
any
other
node
in
the
</ins><a class="tref internalDFN" title="JSON-LD_input" href="#dfn-json-ld_input"><ins class="diff-chg">
JSON-LD
input
</ins></a><ins class="diff-chg">
and
does
not
start
with
the
characters
</ins><code><ins class="diff-chg">
c14n
</ins></code>.<ins class="diff-chg">
The
prefix
is
used
to
temporarily
name
nodes
during
the
normalization
algorithm
in
a
way
that
doesn't
collide
with
the
names
that
already
exist
as
well
as
the
names
that
will
be
generated
by
the
normalization
algorithm.
</ins></dd><dt><dfn title="alpha" id="dfn-alpha"><ins class="diff-chg">
alpha
</ins></dfn><ins class="diff-chg">
and
</ins><dfn title="beta" id="dfn-beta"><ins class="diff-chg">
beta
</ins></dfn><ins class="diff-chg">
values
</ins></dt><dd><ins class="diff-chg">
The
words
</ins><a class="tref internalDFN" title="alpha" href="#dfn-alpha"><ins class="diff-chg">
alpha
</ins></a><ins class="diff-chg">
and
</ins><a class="tref internalDFN" title="beta" href="#dfn-beta"><ins class="diff-chg">
beta
</ins></a><ins class="diff-chg">
refer
to
the
first
and
second
nodes
or
values
being
examined
in
an
algorithm.
The
names
are
merely
used
to
refer
to
each
input
value
to
a
comparison
algorithm.
</ins></dd><dt><dfn title="naming_base_string" id="dfn-naming_base_string-1"><ins class="diff-chg">
naming
base
string
</ins></dfn></dt><dd><ins class="diff-chg">
An
unlabeled
node
naming
prefix
that
is
not
used
by
any
other
node
in
the
</ins><a class="tref internalDFN" title="JSON-LD_input" href="#dfn-json-ld_input"><ins class="diff-chg">
JSON-LD
input
</ins></a><ins class="diff-chg">
and
does
not
start
with
the
characters
</ins><code><ins class="diff-chg">
c14n
</ins></code>.<ins class="diff-chg">
The
prefix
is
used
to
temporarily
name
nodes
during
the
normalization
algorithm
in
a
way
that
doesn't
collide
with
the
names
that
already
exist
as
well
as
the
names
that
will
be
generated
by
the
normalization
algorithm.
</ins></dd></dl></div><div id="normalization-algorithm" class="section"><h4><span class="secno"><ins class="diff-chg">
5.11.2
</ins></span><ins class="diff-chg">
Normalization
Algorithm
</ins></h4><p><ins class="diff-chg">
The
normalization
algorithm
expands
the
</ins><a class="tref internalDFN" title="JSON-LD_input" href="#dfn-json-ld_input"><ins class="diff-chg">
JSON-LD
input
</ins></a>,<ins class="diff-chg">
flattens
the
data
structure,
and
creates
an
initial
set
of
names
for
all
nodes
in
the
graph.
The
flattened
data
structure
is
then
processed
by
the
node
labeling
algorithm
in
order
to
get
a
fully
expanded
and
named
list
of
nodes.
</ins></p><ol class="algorithm"><li><ins class="diff-chg">
Expand
the
</ins><a class="tref internalDFN" title="JSON-LD_input" href="#dfn-json-ld_input"><ins class="diff-chg">
JSON-LD
input
</ins></a><ins class="diff-chg">
according
to
the
steps
in
the
</ins><a href="#expansion-algorithm"><ins class="diff-chg">
Expansion
Algorithm
</ins></a><ins class="diff-chg">
and
store
the
result
as
the
</ins><strong><ins class="diff-chg">
expanded
input
</ins></strong>.</li><li><ins class="diff-chg">
Process
every
object
in
the
</ins><strong><ins class="diff-chg">
expanded
input
</ins></strong><ins class="diff-chg">
searching
for
</ins><code><ins class="diff-chg">
@subject
</ins></code><ins class="diff-chg">
values
that
start
with
the
text
string
</ins><code><ins class="diff-chg">
_:c14n
</ins></code>.<ins class="diff-chg">
If
a
match
is
found,
rename
the
subject
and
all
references
to
the
subject
by
concatenating
</ins><code><ins class="diff-chg">
_:
</ins></code><ins class="diff-chg">
with
the
</ins><a class="tref internalDFN" title="naming_base_string" href="#dfn-naming_base_string-1"><ins class="diff-chg">
naming
base
string
</ins></a><ins class="diff-chg">
and
a
unique
identifier,
such
as
an
incremented
counter
value.
</ins></li><li><ins class="diff-chg">
Create
an
empty
</ins><a class="tref internalDFN" title="list_of_expanded_nodes" href="#dfn-list_of_expanded_nodes"><ins class="diff-chg">
list
of
expanded
nodes
</ins></a><ins class="diff-chg">
and
recursively
process
every
object
in
the
</ins><strong><ins class="diff-chg">
expanded
input
</ins></strong><ins class="diff-chg">
that
is
not
an
expanded
IRI,
typed
literal
or
language
literal,
in
depth-first
order:
</ins><ol class="algorithm"><li><ins class="diff-chg">
If
an
object
does
not
contain
a
</ins><code><ins class="diff-chg">
@subject
</ins></code>,<ins class="diff-chg">
name
it
by
concatenating
</ins><code><ins class="diff-chg">
_:
</ins></code><ins class="diff-chg">
with
the
</ins><a class="tref internalDFN" title="naming_base_string" href="#dfn-naming_base_string-1"><ins class="diff-chg">
naming
base
string
</ins></a><ins class="diff-chg">
and
a
unique
identifier,
such
as
an
incremented
counter
value.
</ins></li><li><ins class="diff-chg">
Add
the
object
to
the
</ins><a class="tref" title="list_of_expanded_nodes."><ins class="diff-chg">
list
of
expanded
nodes
</ins><tref>.</tref></a></li><li><ins class="diff-chg">
Replace
the
reference
to
the
object
with
the
value
of
the
</ins><code><ins class="diff-chg">
@subject
</ins></code><ins class="diff-chg">
in
the
object.
</ins></li><li><ins class="diff-chg">
???duplicate
objects
for
predicates???
</ins></li></ol></li><li><ins class="diff-chg">
Label
all
of
the
nodes
that
contain
a
</ins><code><ins class="diff-chg">
@subject
</ins></code><ins class="diff-chg">
key
associated
with
a
value
starting
with
</ins><code><ins class="diff-chg">
_:
</ins></code><ins class="diff-chg">
according
to
the
steps
in
the
</ins><a href="#node-labeling-algorithm"><ins class="diff-chg">
Node
Labeling
Algorithm
</ins></a>.</li></ol></div><div id="node-labeling-algorithm" class="section"><h4><span class="secno"><ins class="diff-chg">
5.11.3
</ins></span><ins class="diff-chg">
Node
Labeling
Algorithm
</ins></h4><p><ins class="diff-chg">
The
node
labeling
algorithm
takes
the
</ins><a class="tref internalDFN" title="list_of_expanded_nodes" href="#dfn-list_of_expanded_nodes"><ins class="diff-chg">
list
of
expanded
nodes
</ins></a><ins class="diff-chg">
and
sorts
the
list,
deterministically
naming
all
of
the
unlabeled
nodes
in
the
graph.
</ins></p><ol class="algorithm"><li><ins class="diff-chg">
Create
a
</ins><dfn title="forward_mapping" id="dfn-forward_mapping"><ins class="diff-chg">
forward
mapping
</ins></dfn><ins class="diff-chg">
that
relates
graph
nodes
to
the
IRIs
of
the
targets
nodes
that
they
reference.
For
example,
if
a
node
</ins><a class="tref internalDFN" title="alpha" href="#dfn-alpha"><ins class="diff-chg">
alpha
</ins></a><ins class="diff-chg">
refers
to
a
node
</ins><a class="tref internalDFN" title="beta" href="#dfn-beta"><ins class="diff-chg">
beta
</ins></a><ins class="diff-chg">
via
a
property,
the
key
in
the
</ins><a class="tref internalDFN" title="forward_mapping" href="#dfn-forward_mapping"><ins class="diff-chg">
forward
mapping
</ins></a><ins class="diff-chg">
is
the
subject
IRI
of
</ins><a class="tref internalDFN" title="alpha" href="#dfn-alpha"><ins class="diff-chg">
alpha
</ins></a><ins class="diff-chg">
and
the
value
is
an
array
containing
at
least
the
subject
IRI
of
</ins><a class="tref internalDFN" title="beta" href="#dfn-beta"><ins class="diff-chg">
beta
</ins></a>.<ol class="algorithm"><li><ins class="diff-chg">
Add
all
forward
mappings
for
every
node
in
the
graph.
</ins></li></ol></li><li><ins class="diff-chg">
Create
a
</ins><dfn title="reverse_mapping" id="dfn-reverse_mapping"><ins class="diff-chg">
reverse
mapping
</ins></dfn><ins class="diff-chg">
that
relates
graph
nodes
to
every
other
node
that
refers
to
them
in
the
graph.
For
example,
if
a
node
</ins><a class="tref internalDFN" title="alpha" href="#dfn-alpha"><ins class="diff-chg">
alpha
</ins></a><ins class="diff-chg">
refers
to
a
node
</ins><a class="tref internalDFN" title="beta" href="#dfn-beta"><ins class="diff-chg">
beta
</ins></a><ins class="diff-chg">
via
a
property,
the
key
in
the
</ins><a class="tref internalDFN" title="reverse_mapping" href="#dfn-reverse_mapping"><ins class="diff-chg">
reverse
mapping
</ins></a><ins class="diff-chg">
is
the
subject
IRI
for
</ins><a class="tref internalDFN" title="beta" href="#dfn-beta"><ins class="diff-chg">
beta
</ins></a><ins class="diff-chg">
and
the
value
is
an
array
containing
at
least
the
IRI
for
</ins><a class="tref internalDFN" title="alpha" href="#dfn-alpha"><ins class="diff-chg">
alpha
</ins></a>.<ol class="algorithm"><li><ins class="diff-chg">
Add
all
reverse
mappings
for
every
node
in
the
graph.
</ins></li></ol></li><li><ins class="diff-chg">
Label
every
unlabeled
node
according
to
the
</ins><a href="#label-generation-algorithm"><ins class="diff-chg">
Label
Generation
Algorithm
</ins></a><ins class="diff-chg">
in
descending
order
using
the
</ins><a href="#deep-comparison-algorithm"><ins class="diff-chg">
Deep
Comparison
Algorithm
</ins></a><ins class="diff-chg">
to
determine
the
sort
order.
</ins></li></ol></div><div id="shallow-comparison-algorithm" class="section"><h4><span class="secno"><ins class="diff-chg">
5.11.4
</ins></span><ins class="diff-chg">
Shallow
Comparison
Algorithm
</ins></h4><p><ins class="diff-chg">
The
shallow
comparison
algorithm
takes
two
unlabeled
nodes,
</ins><a class="tref internalDFN" title="alpha" href="#dfn-alpha"><ins class="diff-chg">
alpha
</ins></a><ins class="diff-chg">
and
</ins><a class="tref internalDFN" title="beta" href="#dfn-beta"><ins class="diff-chg">
beta
</ins></a>,<ins class="diff-chg">
as
input
and
determines
which
one
should
come
first
in
a
sorted
list.
The
following
algorithm
determines
the
steps
that
are
executed
in
order
to
determine
the
node
that
should
come
first
in
a
list:
</ins></p><ol class="algorithm"><li><ins class="diff-chg">
Compare
the
total
number
of
node
properties.
The
node
with
fewer
properties
is
first.
</ins></li><li><ins class="diff-chg">
Lexicographically
sort
the
property
IRIs
for
each
node
and
compare
the
sorted
lists.
If
an
IRI
is
found
to
be
lexicographically
smaller,
the
node
containing
that
IRI
is
first.
</ins></li><li><ins class="diff-chg">
Compare
the
property
values
against
one
another:
</ins><ol class="algorithm"><li><ins class="diff-chg">
Create
an
</ins><dfn title="alpha_list" id="dfn-alpha_list"><ins class="diff-chg">
alpha
list
</ins></dfn><ins class="diff-chg">
by
adding
all
values
associated
with
the
</ins><a class="tref internalDFN" title="alpha" href="#dfn-alpha"><ins class="diff-chg">
alpha
</ins></a><ins class="diff-chg">
property
that
is
not
an
unlabeled
node.
Track
the
number
of
unlabeled
nodes
not
added
to
the
list
using
an
</ins><dfn title="alpha_unlabeled_counter" id="dfn-alpha_unlabeled_counter"><ins class="diff-chg">
alpha
unlabeled
counter
</ins></dfn>.</li><li><ins class="diff-chg">
Create
a
</ins><dfn title="beta_list" id="dfn-beta_list"><ins class="diff-chg">
beta
list
</ins></dfn><ins class="diff-chg">
by
adding
all
values
associated
with
the
</ins><a class="tref internalDFN" title="beta" href="#dfn-beta"><ins class="diff-chg">
beta
</ins></a><ins class="diff-chg">
property
that
is
not
an
unlabeled
node.
Track
the
number
of
unlabeled
nodes
not
added
to
the
list
using
an
</ins><dfn title="beta_unlabeled_counter" id="dfn-beta_unlabeled_counter"><ins class="diff-chg">
beta
unlabeled
counter
</ins></dfn>.</li><li><ins class="diff-chg">
Compare
the
length
of
</ins><a class="tref internalDFN" title="alpha_list" href="#dfn-alpha_list"><ins class="diff-chg">
alpha
list
</ins></a><ins class="diff-chg">
and
</ins><a class="tref internalDFN" title="beta_list" href="#dfn-beta_list"><ins class="diff-chg">
beta
list
</ins></a>.<ins class="diff-chg">
The
node
associated
with
the
list
containing
the
lesser
number
of
items
is
first.
</ins></li><li><ins class="diff-chg">
Compare
the
</ins><a class="tref internalDFN" title="alpha_unlabeled_counter" href="#dfn-alpha_unlabeled_counter"><ins class="diff-chg">
alpha
unlabeled
counter
</ins></a><ins class="diff-chg">
to
the
</ins><a class="tref internalDFN" title="beta_unlabeled_counter" href="#dfn-beta_unlabeled_counter"><ins class="diff-chg">
beta
unlabeled
counter
</ins></a>,<ins class="diff-chg">
the
node
associated
with
the
lesser
value
is
first.
</ins></li><li><ins class="diff-chg">
Sort
</ins><a class="tref internalDFN" title="alpha_list" href="#dfn-alpha_list"><ins class="diff-chg">
alpha
list
</ins></a><ins class="diff-chg">
and
</ins><a class="tref internalDFN" title="beta_list" href="#dfn-beta_list"><ins class="diff-chg">
beta
list
</ins></a><ins class="diff-chg">
using
the
</ins><a href="#object-comparison-algorithm"><ins class="diff-chg">
Object
Comparison
Algorithm
</ins></a><ins class="diff-chg">
as
the
sorting
comparator.
For
each
offset
into
the
</ins><a class="tref internalDFN" title="alpha_list" href="#dfn-alpha_list"><ins class="diff-chg">
alpha
list
</ins></a>,<ins class="diff-chg">
compare
the
item
at
the
offset
against
the
item
at
the
same
offset
in
the
</ins><a class="tref internalDFN" title="beta_list" href="#dfn-beta_list"><ins class="diff-chg">
beta
list
</ins></a><ins class="diff-chg">
using
the
</ins><a href="#object-comparison-algorithm"><ins class="diff-chg">
Object
Comparison
Algorithm
</ins></a>.<ins class="diff-chg">
The
node
associated
with
the
lesser
item
is
first.
</ins></li></ol></li><li><ins class="diff-chg">
Process
the
</ins><a class="tref internalDFN" title="reverse_mapping" href="#dfn-reverse_mapping"><ins class="diff-chg">
reverse
mapping
</ins></a><ins class="diff-chg">
to
determine
order:
</ins><ol class="algorithm"><li><ins class="diff-chg">
The
node
with
fewer
entries
in
the
</ins><a class="tref internalDFN" title="reverse_mapping" href="#dfn-reverse_mapping"><ins class="diff-chg">
reverse
mapping
</ins></a><ins class="diff-chg">
is
first.
</ins></li><li><ins class="diff-chg">
Sort
the
</ins><a class="tref internalDFN" title="reverse_mapping" href="#dfn-reverse_mapping"><ins class="diff-chg">
reverse
mapping
</ins></a><ins class="diff-chg">
entry
for
</ins><a class="tref internalDFN" title="alpha" href="#dfn-alpha"><ins class="diff-chg">
alpha
</ins></a><ins class="diff-chg">
into
a
</ins><dfn title="list_of_sorted_alpha_mappings" id="dfn-list_of_sorted_alpha_mappings"><ins class="diff-chg">
list
of
sorted
alpha
mappings
</ins></dfn>.<ins class="diff-chg">
Sort
the
</ins><a class="tref internalDFN" title="reverse_mapping" href="#dfn-reverse_mapping"><ins class="diff-chg">
reverse
mapping
</ins></a><ins class="diff-chg">
entry
for
</ins><a class="tref internalDFN" title="beta" href="#dfn-beta"><ins class="diff-chg">
beta
</ins></a><ins class="diff-chg">
into
a
</ins><dfn title="list_of_sorted_beta_mappings" id="dfn-list_of_sorted_beta_mappings"><ins class="diff-chg">
list
of
sorted
beta
mappings
</ins></dfn>.</li><li><ins class="diff-chg">
The
node
associated
with
the
list
of
sorted
mappings
with
the
least
number
of
unlabeled
nodes
is
first.
</ins></li><li><ins class="diff-chg">
For
each
offset
into
the
</ins><a class="tref internalDFN" title="list_of_sorted_alpha_mappings" href="#dfn-list_of_sorted_alpha_mappings"><ins class="diff-chg">
list
of
sorted
alpha
mappings
</ins></a>,<ins class="diff-chg">
compare
the
IRI
at
the
offset
against
the
IRI
at
the
same
offset
in
the
</ins><a class="tref internalDFN" title="list_of_sorted_beta_mappings" href="#dfn-list_of_sorted_beta_mappings"><ins class="diff-chg">
list
of
sorted
beta
mappings
</ins></a>.<ins class="diff-chg">
The
node
associated
with
the
lexicographically
lesser
IRI
is
first.
</ins></li></ol></li><li><ins class="diff-chg">
Otherwise,
the
nodes
are
equal.
</ins></li></ol></div><div id="object-comparison-algorithm" class="section"><h4><span class="secno"><ins class="diff-chg">
5.11.5
</ins></span><ins class="diff-chg">
Object
Comparison
Algorithm
</ins></h4><p><ins class="diff-chg">
The
object
comparison
algorithm
is
designed
to
compare
two
graph
node
property
values,
</ins><a class="tref internalDFN" title="alpha" href="#dfn-alpha"><ins class="diff-chg">
alpha
</ins></a><ins class="diff-chg">
and
</ins><a class="tref internalDFN" title="beta" href="#dfn-beta"><ins class="diff-chg">
beta
</ins></a>,<ins class="diff-chg">
against
the
other.
The
algorithm
is
useful
when
sorting
two
lists
of
graph
node
properties.
</ins></p><ol class="algorithm"><li><ins class="diff-chg">
If
one
of
the
values
is
a
string
and
the
other
is
not,
the
value
that
is
a
string
is
first.
</ins></li><li><ins class="diff-chg">
If
both
values
are
strings,
the
lexicographically
lesser
string
is
first.
</ins></li><li><ins class="diff-chg">
If
one
of
the
values
is
a
literal
and
the
other
is
not,
the
value
that
is
a
literal
is
first.
</ins></li><li><ins class="diff-chg">
If
both
values
are
literals
</ins><ol class="algorithm"><li><ins class="diff-chg">
The
lexicographically
lesser
string
associated
with
</ins><code><ins class="diff-chg">
@literal
</ins></code><ins class="diff-chg">
is
first.
</ins></li><li><ins class="diff-chg">
The
lexicographically
lesser
string
associated
with
</ins><code><ins class="diff-chg">
@datatype
</ins></code><ins class="diff-chg">
is
first.
</ins></li><li><ins class="diff-chg">
The
lexicographically
lesser
string
associated
with
</ins><code><ins class="diff-chg">
@language
</ins></code><ins class="diff-chg">
is
first.
</ins></li></ol></li><li><ins class="diff-chg">
If
both
values
are
expanded
IRIs,
the
lexicographically
lesser
string
associated
with
</ins><code><ins class="diff-chg">
@iri
</ins></code><ins class="diff-chg">
is
first.
</ins></li><li><ins class="diff-chg">
Otherwise,
the
two
values
are
equivalent.
</ins></li></ol></div><div id="deep-comparison-algorithm" class="section"><h4><span class="secno"><ins class="diff-chg">
5.11.6
</ins></span><ins class="diff-chg">
Deep
Comparison
Algorithm
</ins></h4><p><ins class="diff-chg">
DeepCompare(bnodeA,
bnodeB):
</ins></p><ol class="algorithm"><li><ins class="diff-chg">
Return
the
value
of
ShallowCompare
if
it
is
non-zero.
</ins></li><li><ins class="diff-chg">
Compare
property
serializations
and
then
reference
serializations,
recycling
the
mapping
from
property
serializations
for
reference
serializations.
</ins><ol class="algorithm"><li><ins class="diff-chg">
If
the
serialization
for
bnodeA
is
null,
do
SerializeNode(bnodeA,
new
Mapping).
</ins></li><li><ins class="diff-chg">
If
the
serialization
for
bnodeB
is
null,
do
SerializeNode(bnodeA,
new
Mapping).
</ins></li><li><ins class="diff-chg">
Return
the
result
of
a
lexicographical
comparison
of
the
two
serializations.
</ins></li></ol></li></ol></div><div id="node-serialization-algorithm" class="section"><h4><span class="secno"><ins class="diff-chg">
5.11.7
</ins></span><ins class="diff-chg">
Node
Serialization
Algorithm
</ins></h4><p><ins class="diff-chg">
SerializeNode(bnode,
mapping,
dir):
</ins></p><ol class="algorithm"><li><ins class="diff-chg">
If
the
bnode's
label
is
already
marked
as
mapped,
return.
</ins></li><li><ins class="diff-chg">
Mark
the
bnode's
label
as
mapped.
</ins></li><li><ins class="diff-chg">
Assign
the
next
serialization
name
to
the
bnode's
label
and
store
it
in
"top".
</ins></li><li><ins class="diff-chg">
Split
the
bnode's
adjacent
bnodes
into
a
map
and
a
list.
The
map
contains
a
reverse
mapping
of
serialization
names
to
bnode
labels
for
all
labels
in
the
mapping,
the
list
(notMapped)
contains
all
labels
not
in
the
mapping
yet.
</ins></li><li><ins class="diff-chg">
Save
a
copy
of
the
mapping.
</ins></li><li><ins class="diff-chg">
Do
SerializeCombos
for
max(1,
notMapped.length)
using
the
original
mapping
for
the
first
call
and
a
copy
of
the
mapping
for
each
subsequent
call.
</ins></li></ol></div><div id="combinatorial-serialization-algorithm" class="section"><h4><span class="secno"><ins class="diff-chg">
5.11.8
</ins></span><ins class="diff-chg">
Combinatorial
Serialization
Algorithm
</ins></h4><p><ins class="diff-chg">
SerializeCombos(top,
mapping,
mapped,
notMapped,
dir):
</ins></p><ol class="algorithm"><li><ins class="diff-chg">
If
notMapped
is
non-empty,
copy
mapped
and
assign
the
next
serialization
name
to
its
first
bnode,
remove
it
from
the
list,
and
update
mapped.
</ins><ol class="algorithm"><li><ins class="diff-chg">
For
max(1,
notMapped.length)
recurse
into
SerializeCombos
with
the
original
mapping
for
the
first
call
and
a
copy
of
the
mapping
for
each
subsequent
call.
Rotate
notMapped
on
each
iteration.
</ins></li></ol></li><li><ins class="diff-chg">
If
notMapped
is
empty,
save
an
entry
mapping
from
the
bnode's
serialization
name
to
the
reverse
mapping
(mapped)
and
its
sorted
keys
then
do
SerializeMapping.
</ins><ol class="algorithm"><li><ins class="diff-chg">
If
the
serialization
is
lexicographically
less
than
the
current
serialization
or
the
current
serialization
is
null,
then
iterate
over
the
sorted
keys,
get
the
reverse-mapped
adjacent
bnode
and
recursively
call
SerializeNode
on
each
iteration.
</ins></li><li><ins class="diff-chg">
Do
SerializeMapping
then
if
the
serialization
is
lexicographically
less
than
the
current
serialization
or
the
current
serialization
is
null,
then
set
it
as
the
least
serialization
for
the
bnode
in
the
given
edge
direction
('property'
or
'reference').
</ins></li></ol></li></ol></div><div id="mapping-serialization-algorithm" class="section"><h4><span class="secno"><ins class="diff-chg">
5.11.9
</ins></span><ins class="diff-chg">
Mapping
Serialization
Algorithm
</ins></h4><p><ins class="diff-chg">
SerializeMapping(mapping):
(This
function
incrementally
updates
the
relation
serialization
for
a
mapping)
</ins></p><ol class="algorithm"><li><ins class="diff-chg">
If
there
is
an
entry
on
the
mapping's
key
stack,
pop
it
and
iterate
over
every
key.
</ins></li><li><ins class="diff-chg">
For
each
key,
if
an
entry
for
the
key
hasn't
been
added
to
the
mapping
yet,
break
out
of
the
loop.
</ins></li><li><ins class="diff-chg">
Update
the
key
stack
entry's
index.
</ins></li><li><ins class="diff-chg">
If
the
key
has
already
been
serialized,
output
"'_'
+
key"
and
continue.
</ins></li><li><ins class="diff-chg">
For
each
key,
serialize
the
key
then
its
associated
bnode
properties,
then
its
bnode
references.
The
entire
property
list
is
surrounded
by
'['
and
']'
and
so
is
the
reference
list.
Individual
properties/references
are
seperated
by
'|'.
If
a
property
is
an
array,
all
of
the
serializations
are
concatenated
together
with
no
joining
delimiter.
The
'@subject'
property
is
skipped.
The
property
IRI
is
turtle-serialized.
If
a
property
or
reference
object
is
a
bnode,
it
is
serialized
to
'_:',
otherwise
the
turtle
serialization
is
used.
</ins></li><li><ins class="diff-chg">
Join
all
of
the
adjacent
keys
and
add
them
to
the
serialization.
</ins></li><li><ins class="diff-chg">
Push
the
adjacent
keys
onto
the
key
stack.
</ins></li><li><ins class="diff-chg">
Do
SerializeMapping.
</ins></li></ol></div><div id="label-generation-algorithm" class="section"><h4><span class="secno"><ins class="diff-chg">
5.11.10
</ins></span><ins class="diff-chg">
Label
Generation
Algorithm
</ins></h4><p><ins class="diff-chg">
NameNode(bnode):
</ins></p><ol class="algorithm"><li><ins class="diff-chg">
Remove
the
first
blank
node
from
the
list
of
sorted
blank
nodes.
</ins></li><li><ins class="diff-chg">
Give
it
the
next
canonical
name.
</ins></li><li><ins class="diff-chg">
Give
canonical
names
to
each
blank
node
key
in
its
property
serialization
mapping
in
lexicographical
order.
</ins></li><li><ins class="diff-chg">
Give
canonical
names
to
each
blank
node
key
in
its
reference
serialization
mapping
in
lexicographical
order.
</ins></li><li><ins class="diff-chg">
Set
all
serializations
containing
newly-named
blank
nodes
to
null.
</ins></li></ol></div></div><div id="data-round-tripping" class="section"><h3><span class="secno"><ins class="diff-chg">
5.12
</ins></span><ins class="diff-chg">
Data
Round
Tripping
</ins></h3><p><ins class="diff-chg">
When
normalizing
</ins><strong><ins class="diff-chg">
xsd:double
</ins></strong><ins class="diff-chg">
values,
implementers
</ins><em class="rfc2119" title="must"><ins class="diff-chg">
must
</ins></em><ins class="diff-chg">
ensure
that
the
normalized
value
is
a
string.
In
order
to
generate
the
string
from
a
</ins><strong><ins class="diff-chg">
double
</ins></strong><ins class="diff-chg">
value,
output
equivalent
to
the
</ins><code><ins class="diff-chg">
printf("%1.6e",
value)
</ins></code><ins class="diff-chg">
function
in
C
</ins><em class="rfc2119" title="must"><ins class="diff-chg">
must
</ins></em><ins class="diff-chg">
be
used
where
</ins><strong><ins class="diff-chg">
"%1.6e"
</ins></strong><ins class="diff-chg">
is
the
string
formatter
and
</ins><strong><ins class="diff-chg">
value
</ins></strong><ins class="diff-chg">
is
the
value
to
be
converted.
</ins></p><p><ins class="diff-chg">
To
convert
the
a
double
value
in
JavaScript,
implementers
can
use
the
following
snippet
of
code:
</ins></p><pre class="example"><ins class="diff-chg">
// the variable 'value' below is the JavaScript native double value that is to be converted
(value).toExponential(6).replace(/(e(?:\+|-))([0-9])$/,
'$10$2')
</ins></pre><p class="note"><ins class="diff-chg">
When
data
needs
to
be
normalized,
JSON-LD
authors
should
not
use
values
that
are
going
to
undergo
automatic
conversion.
This
is
due
to
the
lossy
nature
of
</ins><strong><ins class="diff-chg">
xsd:double
</ins></strong><ins class="diff-chg">
values.
</ins></p><p class="issue"><ins class="diff-chg">
Round-tripping
data
can
be
problematic
if
we
mix
and
match
@coerce
rules
with
JSON-native
datatypes,
like
integers.
Consider
the
following
code
example:
</ins></p><pre class="example"><ins class="diff-chg">
var myObj = { "@context" : { 
                "number" : "http://example.com/vocab#number",
                "@coerce": {
                   "xsd:nonNegativeInteger": "number"
                }
              },
              "number" : 42 };
// Map the language-native object to JSON-LD
var jsonldText = jsonld.normalize(myObj);
// Convert the normalized object back to a JavaScript object
var
myObj2
=
jsonld.parse(jsonldText);
</ins></pre><p class="issue"><ins class="diff-chg">
At
this
point,
myObj2
and
myObj
will
have
different
values
for
the
"number"
value.
myObj
will
be
the
number
42,
while
myObj2
will
be
the
string
"42".
This
type
of
data
round-tripping
error
can
bite
developers.
We
are
currently
wondering
if
having
a
"coerce
validation"
phase
in
the
parsing/normalization
phases
would
be
a
good
idea.
It
would
prevent
data
round-tripping
issues
like
the
one
mentioned
above.
</ins></p></div><div id="rdf-conversion" class="section"><h3><span class="secno"><ins class="diff-chg">
5.13
</ins></span><ins class="diff-chg">
RDF
Conversion
</ins></h3><p><ins class="diff-chg">
A
JSON-LD
document
</ins><em class="rfc2119" title="may"><ins class="diff-chg">
may
</ins></em><ins class="diff-chg">
be
converted
to
any
other
RDF-compatible
document
format
using
the
algorithm
specified
in
this
section.
</ins></p><p><ins class="diff-chg">
The
JSON-LD
Processing
Model
describes
processing
rules
for
extracting
RDF
from
a
JSON-LD
document.
Note
that
many
uses
of
JSON-LD
may
not
require
generation
of
RDF.
</ins></p><p><ins class="diff-chg">
The
processing
algorithm
described
in
this
section
is
provided
in
order
to
demonstrate
how
one
might
implement
a
JSON-LD
to
RDF
processor.
Conformant
implementations
are
only
required
to
produce
the
same
type
and
number
of
triples
during
the
output
process
and
are
not
required
to
implement
the
algorithm
exactly
as
described.
</ins></p><p class="issue"><ins class="diff-chg">
The
RDF
Conversion
Algorithm
is
a
work
in
progress.
</ins></p><div class="informative section" id="overview"><h4><span class="secno"><ins class="diff-chg">
5.13.1
</ins></span><ins class="diff-chg">
Overview
</ins></h4><p><em><ins class="diff-chg">
This
section
is
non-normative.
</ins></em></p><p><ins class="diff-chg">
JSON-LD
is
intended
to
have
an
easy
to
parse
grammar
that
closely
models
existing
practice
in
using
JSON
for
describing
object
representations.
This
allows
the
use
of
existing
libraries
for
parsing
JSON
in
a
document-oriented
fashion,
or
can
allow
for
stream-based
parsing
similar
to
SAX.
</ins></p><p><ins class="diff-chg">
As
with
other
grammars
used
for
describing
</ins><a class="tref internalDFN" title="Linked_Data" href="#dfn-linked_data"><ins class="diff-chg">
Linked
Data
</ins></a>,<ins class="diff-chg">
a
key
concept
is
that
of
a
</ins><em><ins class="diff-chg">
resource
</ins></em>.<ins class="diff-chg">
Resources
may
be
of
three
basic
types:
</ins><em><ins class="diff-chg">
IRI
</ins></em><ins class="diff-chg">
s,
for
describing
externally
named
entities,
</ins><em><ins class="diff-chg">
BNodes
</ins></em>,<ins class="diff-chg">
resources
for
which
an
external
name
does
not
exist,
or
is
not
known,
and
Literals,
which
describe
terminal
entities
such
as
strings,
dates
and
other
representations
having
a
lexical
representation
possibly
including
an
explicit
language
or
datatype.
</ins></p><p><ins class="diff-chg">
Data
described
with
JSON-LD
may
be
considered
to
be
the
representation
of
a
graph
made
up
of
</ins><a class="tref internalDFN" title="subject" href="#dfn-subject"><ins class="diff-chg">
subject
</ins></a><ins class="diff-chg">
and
</ins><a class="tref internalDFN" title="object" href="#dfn-object"><ins class="diff-chg">
object
</ins></a><ins class="diff-chg">
resources
related
via
a
</ins><a class="tref internalDFN" title="property" href="#dfn-property"><ins class="diff-chg">
property
</ins></a><ins class="diff-chg">
resource.
However,
specific
implementations
may
choose
to
operate
on
the
document
as
a
normal
JSON
description
of
objects
having
attributes.
</ins></p></div><div id="rdf-conversion-algorithm-terms" class="section"><h4><span class="secno"><ins class="diff-chg">
5.13.2
</ins></span><ins class="diff-chg">
RDF
Conversion
Algorithm
Terms
</ins></h4><dl><dt><dfn title="default_graph" id="dfn-default_graph"><ins class="diff-chg">
default
graph
</ins></dfn></dt><dd><ins class="diff-chg">
the
destination
graph
for
all
triples
generated
by
JSON-LD
markup.
</ins></dd></dl></div><div id="rdf-conversion-algorithm" class="section"><h4><span class="secno"><ins class="diff-chg">
5.13.3
</ins></span><ins class="diff-chg">
RDF
Conversion
Algorithm
</ins></h4>
<p>
The
algorithm
below
is
designed
for
in-memory
implementations
with
random
access
to
associative
array
elements.
<del class="diff-old">For
a
description
of
a
streaming
implementation,
see
Appendix
B
.
</del>
</p>
<p>
A
conforming
JSON-LD
processor
<ins class="diff-new">implementing
RDF
conversion
</ins>
<em class="rfc2119" title="must">
must
</em>
implement
a
processing
algorithm
that
results
in
the
same
<a class="tref internalDFN" title="default_graph" href="#dfn-default_graph">
default
graph
</a>
that
the
following
algorithm
generates:
</p>
<ol class="algorithm">
<li id="processing-step-default-context">
Create
a
new
<a class="tref internalDFN" title="processor_state" href="#dfn-processor_state">
processor
state
</a>
with
with
the
<a class="tref internalDFN" title="active_context" href="#dfn-active_context">
active
context
</a>
set
to
the
<del class="diff-old">default
</del>
<a class="tref internalDFN" title="initial_context" href="#dfn-initial_context">
<ins class="diff-chg">initial
</ins>
context
</a>
and
<a class="tref internalDFN" title="active_subject" href="#dfn-active_subject">
active
subject
</a>
and
<a class="tref internalDFN" title="active_property" href="#dfn-active_property">
active
property
</a>
initialized
to
NULL.
</li>
<li id="processing-step-associative">
If
an
associative
array
is
detected,
perform
the
following
steps:
<ol class="algorithm">
<li>
If
the
associative
array
has
a
<code>
@context
</code>
key,
process
the
local
context
as
described
in
<a href="#context">
Context
</a>.
</li>
<li>
<ins class="diff-new">Create
a
new
associative
array
by
mapping
the
keys
from
the
current
associative
array
using
the
</ins><a class="tref internalDFN" title="active_context" href="#dfn-active_context"><ins class="diff-new">
active
context
</ins></a><ins class="diff-new">
to
new
keys
using
the
associated
value
from
the
current
associative
array.
Repeat
the
mapping
until
no
entry
is
found
within
the
</ins><a class="tref internalDFN" title="active_context" href="#dfn-active_context"><ins class="diff-new">
active
context
</ins></a><ins class="diff-new">
for
the
key.
Use
the
new
associative
array
in
subsequent
steps.
</ins></li><li>
If
the
associative
array
has
an
<code>
@iri
</code>
key,
set
the
<a class="tref internalDFN" title="active_object" href="#dfn-active_object">
active
object
</a>
by
performing
<a href="#iri-expansion">
IRI
<del class="diff-old">Processing
</del>
<ins class="diff-chg">Expansion
</ins>
</a>
on
the
associated
value.
Generate
a
triple
representing
the
<a class="tref internalDFN" title="active_subject" href="#dfn-active_subject">
active
subject
</a>,
the
<a class="tref internalDFN" title="active_property" href="#dfn-active_property">
active
property
</a>
and
the
<a class="tref internalDFN" title="active_object" href="#dfn-active_object">
active
object
</a>.
Return
the
<a class="tref internalDFN" title="active_object" href="#dfn-active_object">
active
object
</a>
to
the
calling
location.
<p class="issue">
<code>
<ins class="diff-new">@iri
</ins></code><ins class="diff-new">
really
just
behaves
the
same
as
</ins><code><ins class="diff-new">
@subject
</ins></code>,<ins class="diff-new">
consider
consolidating
them.
</ins></p>
</li>
<li>
If
the
associative
array
has
a
<code>
@literal
</code>
key,
set
the
<a class="tref internalDFN" title="active_object" href="#dfn-active_object">
active
object
</a>
to
a
literal
value
as
follows:
<ol class="algorithm">
<li>
as
a
<a class="tref internalDFN" title="typed_literal" href="#dfn-typed_literal">
typed
literal
</a>
if
the
associative
array
contains
a
<code>
@datatype
</code>
key
after
performing
<a href="#iri-expansion">
IRI
<del class="diff-old">Processing
</del>
<ins class="diff-chg">Expansion
</ins>
</a>
on
the
specified
<code>
@datatype
</code>.
</li>
<li>
otherwise,
as
a
<a class="tref internalDFN" title="plain_literal" href="#dfn-plain_literal">
plain
literal
</a>.
If
the
associative
array
contains
a
<code>
@language
</code>
key,
use
it's
value
to
set
the
language
of
the
plain
literal.
</li>
<li>
Generate
a
triple
representing
the
<a class="tref internalDFN" title="active_subject" href="#dfn-active_subject">
active
subject
</a>,
the
<a class="tref internalDFN" title="active_property" href="#dfn-active_property">
active
property
</a>
and
the
<a class="tref internalDFN" title="active_object" href="#dfn-active_object">
active
object
</a>.
Return
the
<a class="tref internalDFN" title="active_object" href="#dfn-active_object">
active
object
</a>
to
the
calling
location.
</li>
</ol>
</li>
<li id="processing-step-subject">
If
the
associative
array
has
a
<code>
<del class="diff-old">@
</del>
<ins class="diff-chg">@subject
</ins>
</code>
key:
<ol class="algorithm">
<li>
If
the
value
is
a
string,
set
the
<a class="tref internalDFN" title="active_object" href="#dfn-active_object">
active
object
</a>
to
the
result
of
performing
<a href="#iri-expansion">
IRI
<del class="diff-old">Processing
</del>
<ins class="diff-chg">Expansion
</ins>
</a>.
Generate
a
triple
representing
the
<a class="tref internalDFN" title="active_subject" href="#dfn-active_subject">
active
subject
</a>,
the
<a class="tref internalDFN" title="active_property" href="#dfn-active_property">
active
property
</a>
and
the
<a class="tref internalDFN" title="active_object" href="#dfn-active_object">
active
object
</a>.
Set
the
<a class="tref internalDFN" title="active_subject" href="#dfn-active_subject">
active
subject
</a>
to
the
<a class="tref internalDFN" title="active_object" href="#dfn-active_object">
active
object
</a>.
</li>
<li>
Create
a
new
<a class="tref internalDFN" title="processor_state" href="#dfn-processor_state">
processor
state
</a>
using
copies
of
the
<a class="tref internalDFN" title="active_context" href="#dfn-active_context">
active
context
</a>,
<a class="tref internalDFN" title="active_subject" href="#dfn-active_subject">
active
subject
</a>
and
<a class="tref internalDFN" title="active_property" href="#dfn-active_property">
active
property
</a>
and
process
the
value
starting
at
<a href="#processing-step-associative">
Step
2
</a>,
set
the
<a class="tref" title="active__subject">
active
subject
</a>
to
the
result
and
proceed
using
the
previous
<a class="tref internalDFN" title="processor_state" href="#dfn-processor_state">
processor
state
</a>.
</li>
</ol>
</li>
<li>
If
the
associative
array
does
not
have
a
<code>
<del class="diff-old">@
</del>
<ins class="diff-chg">@subject
</ins>
</code>
key,
set
the
<a class="tref" title="active__object">
active
object
</a>
to
newly
generated
<dfn title="blank_node_identifier" id="dfn-blank_node_identifier">
blank
node
identifier
<del class="diff-old">.
</del>
</dfn>.
Generate
a
triple
representing
the
<a class="tref internalDFN" title="active_subject" href="#dfn-active_subject">
active
subject
</a>,
the
<a class="tref internalDFN" title="active_property" href="#dfn-active_property">
active
property
</a>
and
the
<a class="tref internalDFN" title="active_object" href="#dfn-active_object">
active
object
</a>.
Set
the
<a class="tref internalDFN" title="active_subject" href="#dfn-active_subject">
active
subject
</a>
to
the
<a class="tref" title="active__object">
active
object
</a>.
</li>
<li>
For
each
key
in
the
associative
array
that
has
not
already
been
processed,
perform
the
following
steps:
<ol class="algorithm">
<li>
If
the
key
is
<code>
<del class="diff-old">a
</del>
<ins class="diff-chg">@type
</ins>
</code>,
set
the
<a class="tref internalDFN" title="active_property" href="#dfn-active_property">
active
property
</a>
to
<code>
rdf:type
</code>.
</li>
<li>
Otherwise,
set
the
<a class="tref internalDFN" title="active_property" href="#dfn-active_property">
active
property
</a>
to
the
result
of
performing
<a href="#iri-expansion">
IRI
<del class="diff-old">Processing
</del>
<ins class="diff-chg">Expansion
</ins>
</a>
on
the
key.
</li>
<li>
Create
a
new
<a class="tref internalDFN" title="processor_state" href="#dfn-processor_state">
processor
state
</a>
copies
of
the
<a class="tref internalDFN" title="active_context" href="#dfn-active_context">
active
context
</a>,
<a class="tref internalDFN" title="active_subject" href="#dfn-active_subject">
active
subject
</a>
and
<a class="tref internalDFN" title="active_property" href="#dfn-active_property">
active
property
</a>
and
process
the
value
starting
at
<a href="#processing-step-associative">
Step
2
</a>
and
proceed
using
the
previous
<a class="tref internalDFN" title="processor_state" href="#dfn-processor_state">
processor
state
</a>.
</li>
</ol>
</li>
<li>
Return
the
<a class="tref internalDFN" title="active_object" href="#dfn-active_object">
active
object
</a>
to
the
calling
location.
</li>
</ol>
</li>
<li>
If
a
regular
array
is
detected,
process
each
value
in
the
array
by
doing
the
following
returning
the
result
of
processing
the
last
value
in
the
array:
<ol class="algorithm">
<li>
<del class="diff-old">If
the
value
is
a
regular
array,
generate
an
RDF
List
by
linking
each
element
of
the
list
using
rdf:first
and
rdf:next
,
terminating
the
list
with
rdf:nil
using
the
following
sequence:
If
the
list
has
no
element,
generate
a
triple
using
the
active
subject
,
active
property
and
rdf:nil
.
Otherwise,
generate
a
triple
using
using
the
active
subject
,
active
property
and
a
newly
generated
BNode
identified
as
first
bnode
.
For
each
element
other
than
the
last
element
in
the
list:
</del>
Create
a
<del class="diff-old">processor
state
using
the
active
context,
first
bnode
as
the
active
subject
,
and
rdf:first
as
the
active
property
.
Unless
this
is
the
last
element
in
the
list,
generate
a
new
BNode
identified
as
rest
bnode
,
otherwise
use
rdf:nil
.
Generate
a
new
triple
using
first
bnode
,
rdf:rest
and
rest
bnode
.
Set
first
bnode
to
rest
bnode
.
Otherwise,
create
a
</del>
new
<a class="tref internalDFN" title="processor_state" href="#dfn-processor_state">
processor
state
</a>
<ins class="diff-new">using
</ins>
copies
of
the
<a class="tref" title="active__context">
active
context
</a>,
<a class="tref internalDFN" title="active_subject" href="#dfn-active_subject">
active
subject
</a>
and
<a class="tref internalDFN" title="active_property" href="#dfn-active_property">
active
property
</a>
and
process
the
value
starting
at
<a href="#processing-step-associative">
Step
2
</a>
<del class="diff-old">and
</del>
<ins class="diff-chg">then
</ins>
proceed
using
the
previous
<a class="tref internalDFN" title="processor_state" href="#dfn-processor_state">
processor
state
</a>.
</li>
</ol>
</li>
<li>
If
a
string
is
<del class="diff-old">detected,
generate
</del>
<ins class="diff-chg">detected:
</ins><ol class="algorithm"><li><ins class="diff-chg">
If
the
</ins><a class="tref internalDFN" title="active_property" href="#dfn-active_property"><ins class="diff-chg">
active
property
</ins></a><ins class="diff-chg">
is
the
target
of
</ins>
a
<del class="diff-old">triple
using
</del>
<code>
<ins class="diff-chg">@iri
</ins></code><ins class="diff-chg">
coercion,
set
</ins>
the
<a class="tref internalDFN" title="active_object" href="#dfn-active_object">
active
<del class="diff-old">subject
,
</del>
<ins class="diff-chg">object
</ins></a><ins class="diff-chg">
by
performing
</ins><a href="#iri-expansion"><ins class="diff-chg">
IRI
Expansion
</ins></a><ins class="diff-chg">
on
the
string.
</ins></li><li><ins class="diff-chg">
Otherwise,
if
the
</ins><a class="tref internalDFN" title="active_property" href="#dfn-active_property"><ins class="diff-chg">
active
property
</ins></a><ins class="diff-chg">
is
the
target
of
coercion,
set
the
</ins>
<a class="tref internalDFN" title="active_object" href="#dfn-active_object">
active
object
</a>
<ins class="diff-new">by
creating
a
</ins><a class="tref internalDFN" title="typed_literal" href="#dfn-typed_literal"><ins class="diff-new">
typed
literal
</ins></a><ins class="diff-new">
using
the
string
</ins>
and
<ins class="diff-new">the
coercion
key
as
the
datatype
IRI.
</ins></li><li><ins class="diff-new">
Otherwise,
set
the
</ins><a class="tref internalDFN" title="active_object" href="#dfn-active_object"><ins class="diff-new">
active
object
</ins></a><ins class="diff-new">
to
</ins>
a
<a class="tref internalDFN" title="plain_literal" href="#dfn-plain_literal">
plain
literal
</a>
value
created
from
the
string.
</li>
</ol>
<ins class="diff-new">Generate
a
triple
representing
the
</ins><a class="tref internalDFN" title="active_subject" href="#dfn-active_subject"><ins class="diff-new">
active
subject
</ins></a>,<ins class="diff-new">
the
</ins><a class="tref internalDFN" title="active_property" href="#dfn-active_property"><ins class="diff-new">
active
property
</ins></a><ins class="diff-new">
and
the
</ins><a class="tref internalDFN" title="active_object" href="#dfn-active_object"><ins class="diff-new">
active
object
</ins></a>.</li>
<li>
If
a
number
is
detected,
generate
a
<a class="tref internalDFN" title="typed_literal" href="#dfn-typed_literal">
typed
literal
</a>
using
a
string
representation
of
the
value
with
datatype
set
to
either
<code>
xsd:integer
</code>
or
<code>
xsd:double
</code>,
depending
on
if
the
value
contains
a
fractional
and/or
an
exponential
component.
Generate
a
triple
using
the
<a class="tref" title="active__subject">
active
subject
</a>,
<a class="tref internalDFN" title="active_property" href="#dfn-active_property">
active
<del class="diff-old">object
</del>
<ins class="diff-chg">property
</ins>
</a>
and
the
generated
typed
literal.
</li>
<li>
Otherwise,
if
<strong>
true
</strong>
or
<strong>
false
</strong>
is
detected,
generate
a
triple
using
the
<a class="tref internalDFN" title="active_subject" href="#dfn-active_subject">
active
subject
</a>,
<a class="tref internalDFN" title="active_property" href="#dfn-active_property">
active
<del class="diff-old">object
</del>
<ins class="diff-chg">property
</ins>
</a>
and
a
<a class="tref internalDFN" title="typed_literal" href="#dfn-typed_literal">
typed
literal
</a>
value
created
from
the
string
representation
of
the
value
with
datatype
set
to
<code>
xsd:boolean
</code>.
</li>
</ol>
</div>
<del class="diff-old">8.
Best
Practices
The
nature
of
Web
programming
allows
one
to
use
basic
technologies,
such
as
JSON-LD,
across
a
variety
of
systems
and
environments.
This
section
attempts
to
describe
some
of
those
environments
and
the
way
in
which
JSON-LD
can
be
integrated
in
order
to
help
alleviate
certain
development
headaches.
8.1
JavaScript
It
is
expected
that
JSON-LD
will
be
used
quite
a
bit
in
JavaScript
environments,
however,
features
like
the
expanded
form
for
object
values
mean
that
using
JSON-LD
directly
in
JavaScript
may
be
annoying
without
a
middleware
layer
such
as
a
simple
library
that
converts
JSON-LD
markup
before
JavaScript
uses
it.
One
could
say
that
JSON-LD
is
a
good
fit
for
the
RDF
API,
which
enables
a
variety
of
RDF-based
Web
Applications,
but
some
don't
want
to
require
that
level
of
functionality
just
to
use
JSON-LD.
The
group
is
still
discussing
the
best
way
to
proceed,
so
input
on
how
JSON-LD
could
more
easily
be
utilized
in
JavaScript
environments
would
be
very
much
appreciated.
8.2
Schema-less
Databases
Databases
such
as
CouchDB
and
MongoDB
allow
the
creation
of
schema-less
data
stores.
RDF
is
a
type
of
schema-less
data
model
and
thus
lends
itself
to
databases
such
as
CouchDB
and
MongoDB.
Both
of
these
databases
can
use
JSON-LD
as
their
storage
format.
The
group
needs
feedback
from
CouchDB
and
MongoDB
experts
regarding
the
usefulness
of
JSON-LD
in
those
environments.
MongoDB
does
not
allow
the
'.'
character
to
be
used
in
key
names.
This
prevents
developers
from
storing
IRIs
as
keys,
which
also
prevents
storage
of
the
data
in
normalized
form.
While
this
issue
can
be
avoided
by
using
CURIEs
for
key
values,
it
is
not
known
if
this
mechanism
is
enough
to
allow
JSON-LD
to
be
used
in
MongoDB
in
a
way
that
is
useful
to
developers.
</del>
</div>
</div>
<div id="experimental-concepts" class="section">
<h2>
<span class="secno">
<del class="diff-old">9.
</del>
<ins class="diff-chg">6.
</ins>
</span>
<del class="diff-old">Advanced
</del>
<ins class="diff-chg">Experimental
</ins>
Concepts
</h2>
<p class="issue">
There
are
a
few
advanced
concepts
where
it
is
not
clear
whether
or
not
the
JSON-LD
specification
is
going
to
support
the
complexity
necessary
to
support
each
concept.
The
entire
section
on
Advanced
Concepts
should
be
considered
as
discussion
points;
it
is
merely
a
list
of
possibilities
where
all
of
the
benefits
and
drawbacks
have
not
been
explored.
</p>
<del class="diff-old">9.1
Vocabulary
Profiles
One
of
the
more
powerful
features
of
RDFa
1.1
Core
is
the
ability
to
specify
a
collection
of
prefixes
and
terms
that
can
be
re-used
by
a
processor
to
simplfy
markup.
JSON-LD
provides
a
similar
mechanism
called
Vocabulary
Profiles,
which
is
the
inclusion
of
a
context
external
to
the
JSON-LD
document.
The
example
below
demonstrates
how
one
may
specify
an
external
Vocabulary
Profile.
Assume
the
following
profile
exists
at
this
imaginary
URL:
http://example.org/profiles/contacts
.
{
  "@context": 
  {
     "xsd": "http://www.w3.org/2001/XMLSchema#",
     "name": "http://xmlns.com/foaf/0.1/name",
     "age": "http://xmlns.com/foaf/0.1/age",
     "homepage": "http://xmlns.com/foaf/0.1/homepage",
     "#types":
     {
        "age": "xsd:integer",
        "homepage": "xsd:anyURI",
     }
  }
}
The
profile
listed
above
can
be
used
in
the
following
way:
{
  "@profile": "http://example.org/profiles/contacts",
  "name": "John Smith",
  "age": "41",
  "homepage": "http://example.org/home/"
}
The
example
above
would
generate
the
following
triples:
_:bnode1
   &lt;http://xmlns.com/foaf/0.1/name&gt;
      "John Smith" .
_:bnode1
   &lt;http://xmlns.com/foaf/0.1/age&gt;
      "41"^^http://www.w3.org/2001/XMLSchema#integer .
_:bnode1
   &lt;http://xmlns.com/foaf/0.1/homepage&gt;
&lt;http://example.org/home/&gt;
.
</del>
<div id="disjoint-graphs" class="section">
<h3>
<span class="secno">
<del class="diff-old">9.2
</del>
<ins class="diff-chg">6.1
</ins>
</span>
Disjoint
Graphs
</h3>
<p>
When
serializing
an
RDF
graph
that
contains
two
or
more
sections
of
the
graph
which
are
entirely
disjoint,
one
must
use
an
array
to
express
the
graph
as
two
graphs.
This
may
not
be
acceptable
to
some
authors,
who
would
rather
express
the
information
as
one
graph.
Since,
by
definition,
disjoint
graphs
require
there
to
be
two
top-level
objects,
JSON-LD
utilizes
a
mechanism
that
allows
disjoint
graphs
to
be
expressed
using
a
single
graph.
</p>
<p>
Assume
the
following
RDF
graph:
</p>
<pre class="example">
&lt;http://example.org/people#john&gt; 
   &lt;http://www.w3.org/1999/02/22-rdf-syntax-ns#type&gt;
      &lt;http://xmlns.com/foaf/0.1/Person&gt; .
&lt;http://example.org/people#jane&gt; 
   &lt;http://www.w3.org/1999/02/22-rdf-syntax-ns#type&gt;
&lt;http://xmlns.com/foaf/0.1/Person&gt;
.
</pre>
<p>
Since
the
two
subjects
are
entirely
disjoint
with
one
another,
it
is
impossible
to
express
the
RDF
graph
above
using
a
single
JSON-LD
associative
array.
</p>
<p>
In
JSON-LD,
one
can
use
the
subject
to
express
disjoint
graphs
as
a
single
graph:
</p>
<pre class="example">
{
<del class="diff-old">  "@": 
</del>
<ins class="diff-chg">  "@coerce": {
    "foaf": "http://xmlns.com/foaf/0.1/"
  },
  "@subject": 
</ins>
  [
    {
<del class="diff-old">      "@": "http://example.org/people#john",
      "a": "foaf:Person"
</del>
<ins class="diff-chg">      "@subject": "http://example.org/people#john",
      "@type": "foaf:Person"
</ins>
    },
    {
<del class="diff-old">      "@": "http://example.org/people#jane",
      "a": "foaf:Person"
</del>
<ins class="diff-chg">      "@subject": "http://example.org/people#jane",
      "@type": "foaf:Person"
</ins>
    }
  ]
}
</pre>
<p>
A
disjoint
graph
could
also
be
expressed
like
so:
</p>
<pre class="example">
[
  {
<del class="diff-old">    "@": "http://example.org/people#john",
    "a": "foaf:Person"
</del>
<ins class="diff-chg">    "@subject": "http://example.org/people#john",
    "@type": "http://xmlns.com/foaf/0.1/Person"
</ins>
  },
  {
<del class="diff-old">    "@": "http://example.org/people#jane",
    "a": "foaf:Person"
</del>
<ins class="diff-chg">    "@subject": "http://example.org/people#jane",
    "@type": "http://xmlns.com/foaf/0.1/Person"
</ins>
  }
]
</pre>
</div>
<div id="lists" class="section">
<h3>
<span class="secno">
<del class="diff-old">9.3
</del>
<ins class="diff-chg">6.2
</ins>
</span>
<del class="diff-old">The
JSON-LD
API
</del>
<ins class="diff-chg">Lists
</ins>
</h3>
<p>
<del class="diff-old">This
API
provides
a
clean
mechanism
that
enables
developers
to
convert
JSON-LD
data
into
a
format
that
is
easier
to
work
with
</del>
<ins class="diff-chg">Because
graphs
do
not
describe
ordering
for
links
between
nodes,
multi-valued
properties
</ins>
in
<del class="diff-old">various
programming
languages.
</del>
<ins class="diff-chg">JSON
do
not
provide
an
ordering
of
the
listed
objects.
For
example,
consider
the
following
simple
document:
</ins>
</p>
<del class="diff-old">]
interface  {
};
</del>
  <pre class="example">
<ins class="diff-chg">{
...
  "@subject": "http://example.org/people#joebob",
  "foaf:nick": <span class="diff">["joe", "bob", "jaybee"]</span>,
...
}
</ins>
</pre>
<del class="diff-old">9.3.1
Methods
toGraph
Parses
JSON-LD
and
transforms
</del>
<p>
<ins class="diff-chg">This
results
in
three
triples
being
generated,
each
relating
</ins>
the
<del class="diff-old">data
into
</del>
<ins class="diff-chg">subject
to
</ins>
an
<del class="diff-old">Graph,
which
is
compatible
</del>
<ins class="diff-chg">individual
object,
</ins>
with
<del class="diff-old">the
RDF
Interfaces
API
specification
</del>
<ins class="diff-chg">no
inherent
order.
To
address
this
issue,
RDF-based
languages,
such
as
</ins>
[
<cite>
<del class="diff-old">RDF-INTERFACES
</del>
<a class="bibref" rel="biblioentry" href="#bib-TURTLE">
<ins class="diff-chg">TURTLE
</ins>
</a>
</cite>
<del class="diff-old">].
This
method
will
return
null
if
there
are
any
errors,
or
if
</del>
<ins class="diff-chg">]
use
</ins>
the
<del class="diff-old">RDF
Interfaces
API
is
not
available
for
use.
Parameter
Type
Nullable
Optional
Description
jsonld
</del>
<ins class="diff-chg">concept
of
an
</ins>
<code>
<del class="diff-old">DOMString
</del>
<ins class="diff-chg">rdf:List
</ins>
</code>
<ins class="diff-new">(as
described
in
[
</ins><cite>
<del class="diff-old">✘
✘
The
JSON-LD
string
to
parse
into
the
RDFGraph.
callback
JSONLDParserCallback
</del>
<a class="bibref" rel="biblioentry" href="#bib-RDF-SCHEMA">
<ins class="diff-chg">RDF-SCHEMA
</ins>
</a>
<del class="diff-old">✔
✔
A
callback
that
is
called
whenever
</del>
</cite>
<ins class="diff-chg">]).
This
uses
</ins>
a
<del class="diff-old">processing
error
occurs
on
the
given
JSON-LD
string.
No
exceptions.
Return
type:
Graph
toProjection
Parses
</del>
<ins class="diff-chg">sequence
of
unlabeled
nodes
with
properties
describing
a
value,
a
null-terminated
next
property.
Without
specific
syntactical
support,
this
could
be
represented
in
</ins>
JSON-LD
<del class="diff-old">text
into
an
RDF
API
Projection
object
</del>
as
<del class="diff-old">specified
by
</del>
<ins class="diff-chg">follows:
</ins></p>  <pre class="example"><ins class="diff-chg">
{
...
  "@subject": "http://example.org/people#joebob",
  "foaf:nick": <span class="diff">{</span>,
</ins>    <span class="diff">"@first": "joe"</span>,    <span class="diff">"@rest": {</span>      <span class="diff">"@first": "bob"</span>,      <span class="diff">"@rest": {</span>        <span class="diff">"@first": "jaybee"</span>,        <span class="diff">"@rest": "@nil"</span>        <span class="diff">}</span>      <span class="diff">}</span>    <span class="diff">}</span>  <span class="diff">}</span>,<ins class="diff-chg">
...
}
</ins></pre><p><ins class="diff-chg">
As
this
notation
is
rather
unwieldy
and
</ins>
the
<del class="diff-old">RDF
API
specification
[
RDF-API
].
If
there
are
any
errors,
null
</del>
<ins class="diff-chg">notion
of
ordered
collections
</ins>
is
<del class="diff-old">returned.
Parameter
Type
Nullable
Optional
Description
jsonld
DOMString
✘
✘
The
JSON-LD
string
</del>
<ins class="diff-chg">rather
important
in
data
modeling,
it
is
useful
</ins>
to
<del class="diff-old">parse
into
</del>
<ins class="diff-chg">have
specific
language
support.
In
JSON-LD,
a
list
may
be
represented
using
</ins>
the
<del class="diff-old">Projection.
template
</del>
<code>
<del class="diff-old">object
</del>
<ins class="diff-chg">@list
</ins>
</code>
<del class="diff-old">✔
✘
The
Projection
template
to
use
when
building
</del>
<ins class="diff-chg">keyword
as
follows:
</ins></p>  <pre class="example"><ins class="diff-chg">
{
...
  "@subject": "http://example.org/people#joebob",
  "foaf:nick": <span class="diff">{"@list": ["joe", "bob", "jaybee"]}</span>,
...
}
</ins></pre><p><ins class="diff-chg">
This
describes
</ins>
the
<del class="diff-old">Projection.
subject
DOMString
✔
✘
The
subject
to
</del>
use
<del class="diff-old">when
building
the
Projection.
callback
JSONLDParserCallback
✔
✔
A
callback
that
</del>
<ins class="diff-chg">of
this
array
as
being
ordered,
and
order
</ins>
is
<del class="diff-old">called
whenever
</del>
<ins class="diff-chg">maintained
through
normalization
and
RDF
conversion.
If
every
use
of
</ins>
a
<del class="diff-old">processing
error
occurs
on
the
</del>
given
<del class="diff-old">JSON-LD
string.
No
exceptions.
Return
type:
object
The
JSONLDParserCallback
</del>
<ins class="diff-chg">multi-valued
property
</ins>
is
<del class="diff-old">called
whenever
</del>
a
<del class="diff-old">processing
error
occurs
on
input
data.
</del>
<ins class="diff-chg">list,
this
may
be
abbreviated
by
adding
an
</ins><code><ins class="diff-chg">
@coerce
</ins></code><ins class="diff-chg">
term:
</ins>
</p>
<del class="diff-old">]
interface  {
};
</del>
  <pre class="example">
<ins class="diff-chg">{
</ins>  <span class="diff">"@context": {</span><ins class="diff-chg">
    ...
</ins>    <span class="diff">"@context": {</span>      <span class="diff">"@list": ["foaf:nick"]</span>    <span class="diff">}</span>  <span class="diff">}</span>,<ins class="diff-chg">
...
  "@subject": "http://example.org/people#joebob",
  "foaf:nick": <span class="diff">["joe", "bob", "jaybee"]</span>,
...
}
</ins>
</pre>
<div id="expansion-2" class="section">
<h4 id="list-expansion">
<span class="secno">
<del class="diff-old">9.3.2
</del>
<ins class="diff-chg">6.2.1
</ins>
</span>
<del class="diff-old">Methods
</del>
<ins class="diff-chg">Expansion
</ins>
</h4>
<del class="diff-old">error
This
callback
is
invoked
whenever
an
error
occurs
during
processing.
Parameter
Type
Nullable
Optional
Description
error
DOMString
✘
✘
A
descriptive
error
string
returned
by
the
processor.
No
exceptions.
Return
type:
void
</del>
<p class="issue">
<ins class="diff-chg">TBD.
</ins></p>
</div>
<div id="normalization-2" class="section">
<h4 id="list-normalization">
<del class="diff-old">The
following
example
demonstrates
how
to
convert
JSON-LD
to
a
projection
that
is
directly
usable
in
a
programming
environment:
</del>
<span class="secno">
<ins class="diff-chg">6.2.2
</ins></span><ins class="diff-chg">
Normalization
</ins></h4><p class="issue"><ins class="diff-chg">
TBD.
</ins>
</p>
<del class="diff-old">// retrieve JSON-LD from a Web Service
var jsonldString = fetchPerson();
// This map, usually defined once per script, defines how to map incoming 
// JSON-LD to JavaScript objects
var myTemplate = { "http://xmlns.com/foaf/0.1/name" : "name",
                   "http://xmlns.com/foaf/0.1/age" : "age",
                  "http://xmlns.com/foaf/0.1/homepage" : "homepage" };
// Map the JSON-LD to a language-native object
var person = jsonld.toProjection(jsonldString, myTemplate);
// Use the language-native object
alert(person.name + " is " + person.age + " years old. " +
"Their
homepage
is:
"
+
person.homepage);
A
JSON-LD
Serializer
is
also
available
to
map
a
language-native
object
to
JSON-LD.
]
interface  {
};
</del>
</div>
<div id="rdf-conversion-1" class="section">
<h4 id="list-rdf">
<span class="secno">
<del class="diff-old">9.3.3
</del>
<ins class="diff-chg">6.2.3
</ins>
</span>
<del class="diff-old">Methods
</del>
<ins class="diff-chg">RDF
Conversion
</ins>
</h4>
<del class="diff-old">normalize
Serializes
a
language-native
object
into
a
normalized
JSON-LD
string.
Normalization
is
important
when
performing
things
like
equality
comparison
and
digital
signature
creation
and
verification.
Parameter
Type
Nullable
Optional
Description
obj
object
✘
✘
An
associative
array
</del>
<p>
<ins class="diff-chg">To
support
RDF
Conversion
</ins>
of
<del class="diff-old">key-value
pairs
that
should
be
converted
to
a
JSON-LD
string.
It
is
assumed
that
a
map
already
exists
for
the
data.
No
exceptions.
Return
type:
DOMString
The
Normalization
</del>
<ins class="diff-chg">lists,
</ins><a href="#rdf-conversion-algorithm"><ins class="diff-chg">
RDF
Conversion
</ins>
Algorithm
<del class="diff-old">This
algorithm
is
very
rough,
untested,
and
probably
contains
many
bugs.
Use
at
your
own
risk.
It
will
change
in
the
coming
months.
The
JSON-LD
normalization
algorithm
</del>
</a>
is
<ins class="diff-new">updated
</ins>
as
follows:
</p>
<ol class="algorithm update">
<li>
<del class="diff-old">Remove
</del>
<span class="list-number">
<ins class="diff-chg">2.4a.
</ins></span><ins class="diff-chg">
If
</ins>
the
<ins class="diff-new">associative
array
has
a
</ins>
<code>
<del class="diff-old">@context
</del>
<ins class="diff-chg">@list
</ins>
</code>
key
and
<del class="diff-old">preserve
it
as
</del>
the
<del class="diff-old">transformation
map
while
running
this
algorithm.
</del>
<ins class="diff-chg">value
is
an
array
process
the
value
as
a
list
starting
at
</ins><a href="#processing-step-list"><ins class="diff-chg">
Step
3a
</ins></a>.
</li>
<li>
<del class="diff-old">For
each
key
</del>
<span class="list-number">
<ins class="diff-chg">2.7.3.
</ins></span><ins class="diff-chg">
Create
a
new
</ins><a class="tref internalDFN" title="processor_state" href="#dfn-processor_state"><ins class="diff-chg">
processor
state
</ins></a><ins class="diff-chg">
copies
of
the
</ins><a class="tref internalDFN" title="active_context" href="#dfn-active_context"><ins class="diff-chg">
active
context
</ins></a>,<a class="tref internalDFN" title="active_subject" href="#dfn-active_subject"><ins class="diff-chg">
active
subject
</ins></a><ins class="diff-chg">
and
</ins><a class="tref internalDFN" title="active_property" href="#dfn-active_property"><ins class="diff-chg">
active
property
</ins></a>.
<ol class="algorithm">
<li>
If
the
<del class="diff-old">key
</del>
<a class="tref internalDFN" title="active_property" href="#dfn-active_property">
<ins class="diff-chg">active
property
</ins></a>
is
<ins class="diff-new">the
target
of
</ins>
a
<del class="diff-old">CURIE,
expand
</del>
<code>
<ins class="diff-chg">@list
</ins></code><ins class="diff-chg">
coercion,
and
</ins>
the
<del class="diff-old">CURIE
to
</del>
<ins class="diff-chg">value
is
</ins>
an
<del class="diff-old">IRI
</del>
<ins class="diff-chg">array,
process
the
value
as
a
list
starting
at
</ins><a href="#processing-step-list"><ins class="diff-chg">
Step
3a
</ins></a>.</li><li><ins class="diff-chg">
Otherwise,
process
the
value
starting
at
</ins><a href="#processing-step-associative"><ins class="diff-chg">
Step
2
</ins></a>.</li><li><ins class="diff-chg">
Proceed
</ins>
using
the
<del class="diff-old">transformation
map
</del>
<ins class="diff-chg">previous
</ins><a class="tref internalDFN" title="processor_state" href="#dfn-processor_state"><ins class="diff-chg">
processor
state
</ins>
</a>.
</li>
</ol>
</li>
<del class="diff-old">For
</del>
<li id="processing-step-list">
<span class="list-number">
<ins class="diff-chg">3a.
</ins></span><ins class="diff-chg">
Generate
an
RDF
List
by
linking
</ins>
each
<del class="diff-old">value
If
</del>
<ins class="diff-chg">element
of
</ins>
the
<del class="diff-old">value
should
be
type
coerced
per
</del>
<ins class="diff-chg">list
using
</ins><code><ins class="diff-chg">
rdf:first
</ins></code><ins class="diff-chg">
and
</ins><code><ins class="diff-chg">
rdf:next
</ins></code>,<ins class="diff-chg">
terminating
</ins>
the
<del class="diff-old">transformation
map
,
ensure
that
it
is
transformed
to
</del>
<ins class="diff-chg">list
with
</ins><code><ins class="diff-chg">
rdf:nil
</ins></code><ins class="diff-chg">
using
</ins>
the
<del class="diff-old">new
value.
</del>
<ins class="diff-chg">following
sequence:
</ins><ol class="algorithm">
<li>
If
the
<del class="diff-old">value
is
</del>
<ins class="diff-chg">list
has
no
element,
generate
</ins>
a
<del class="diff-old">CURIE,
expand
the
CURIE
to
an
IRI
</del>
<ins class="diff-chg">triple
</ins>
using
the
<del class="diff-old">transformation
map
.
</del>
<a class="tref internalDFN" title="active_subject" href="#dfn-active_subject">
<ins class="diff-chg">active
subject
</ins></a>,<a class="tref internalDFN" title="active_property" href="#dfn-active_property"><ins class="diff-chg">
active
property
</ins></a><ins class="diff-chg">
and
</ins><code><ins class="diff-chg">
rdf:nil
</ins></code>.
</li>
<li>
<del class="diff-old">If
the
value
is
</del>
<ins class="diff-chg">Otherwise,
generate
</ins>
a
<del class="diff-old">typed
literal
</del>
<ins class="diff-chg">triple
using
using
the
</ins><a class="tref internalDFN" title="active_subject" href="#dfn-active_subject"><ins class="diff-chg">
active
subject
</ins></a>,<a class="tref internalDFN" title="active_property" href="#dfn-active_property"><ins class="diff-chg">
active
property
</ins>
</a>
and
<ins class="diff-new">a
newly
generated
BNode
identified
as
</ins><em><ins class="diff-new">
first
</ins><dfn title="blank_node_identifier" id="dfn-blank_node_identifier-1"><ins class="diff-new">
blank
node
identifier
</ins></dfn></em>.</li><li><ins class="diff-new">
For
each
element
other
than
</ins>
the
<del class="diff-old">type
is
</del>
<ins class="diff-chg">last
element
in
the
list:
</ins><ol class="algorithm"><li><ins class="diff-chg">
Create
</ins>
a
<del class="diff-old">CURIE,
expand
it
to
an
IRI
</del>
<ins class="diff-chg">processor
state
</ins>
using
the
<del class="diff-old">transformation
map
.
When
generating
</del>
<ins class="diff-chg">active
context,
</ins><em><ins class="diff-chg">
first
</ins><dfn title="blank_node_identifier" id="dfn-blank_node_identifier-2"><ins class="diff-chg">
blank
node
identifier
</ins></dfn></em><ins class="diff-chg">
as
</ins>
the
<del class="diff-old">final
value,
use
expanded
object
value
form
to
store
all
IRIs,
typed
literals
</del>
<a class="tref internalDFN" title="active_subject" href="#dfn-active_subject">
<ins class="diff-chg">active
subject
</ins></a>,
and
<del class="diff-old">plain
literal
s
with
language
information.
</del>
<code>
<ins class="diff-chg">rdf:first
</ins></code><ins class="diff-chg">
as
the
</ins><a class="tref internalDFN" title="active_property" href="#dfn-active_property"><ins class="diff-chg">
active
property
</ins></a>.
</li>
<li>
<del class="diff-old">Output
each
sorted
key-value
pair
without
any
extraneous
whitespace.
If
the
value
is
an
associative
array,
perform
</del>
<ins class="diff-chg">Unless
</ins>
this
<del class="diff-old">algorithm,
starting
at
step
#1,
recursively
on
the
sub-tree.
There
should
be
no
nesting
in
the
outputted
JSON
data.
That
is,
</del>
<ins class="diff-chg">is
</ins>
the
<del class="diff-old">top-most
</del>
<ins class="diff-chg">last
</ins>
element
<del class="diff-old">should
be
an
array.
Each
item
</del>
in
the
<del class="diff-old">array
contains
a
single
subject
with
</del>
<ins class="diff-chg">list,
generate
</ins>
a
<del class="diff-old">corresponding
array
of
properties
in
UTF-8
sort
order.
Any
related
objects
that
are
complex
objects
themselves
should
be
given
</del>
<ins class="diff-chg">new
BNode
identified
as
</ins><em><ins class="diff-chg">
rest
</ins><dfn title="blank_node_identifier" id="dfn-blank_node_identifier-3"><ins class="diff-chg">
blank
node
identifier
</ins></dfn></em>,<ins class="diff-chg">
otherwise
use
</ins><code><ins class="diff-chg">
rdf:nil
</ins></code>.</li><li><ins class="diff-chg">
Generate
</ins>
a
<del class="diff-old">top-level
object
in
the
top-level
array.
</del>
<ins class="diff-chg">new
triple
using
</ins><em><ins class="diff-chg">
first
</ins><dfn title="blank_node_identifier" id="dfn-blank_node_identifier-4"><ins class="diff-chg">
blank
node
identifier
</ins></dfn></em>,<code><ins class="diff-chg">
rdf:rest
</ins></code><ins class="diff-chg">
and
</ins><em><ins class="diff-chg">
rest
</ins><dfn title="blank_node_identifier" id="dfn-blank_node_identifier-5"><ins class="diff-chg">
blank
node
identifier
</ins></dfn></em>.
</li>
<del class="diff-old">Note
that
normalizing
named
</del>
<li>
<ins class="diff-chg">Set
</ins><em><ins class="diff-chg">
first
</ins><dfn title="blank_node_identifier" id="dfn-blank_node_identifier-6">
blank
<del class="diff-old">nodes
is
impossible
at
present
since
one
would
have
</del>
<ins class="diff-chg">node
identifier
</ins></dfn></em>
to
<del class="diff-old">specify
a
</del>
<em>
<ins class="diff-chg">rest
</ins><dfn title="blank_node_identifier" id="dfn-blank_node_identifier-7">
blank
node
<del class="diff-old">naming
algorithm.
For
the
time
being,
you
cannot
normalize
graphs
that
contain
named
blank
nodes.
However,
normalizing
graphs
</del>
<ins class="diff-chg">identifier
</ins></dfn></em>.</li></ol></li></ol></li></ol></div></div></div><div class="appendix section" id="markup-examples"><h2><span class="secno"><ins class="diff-chg">
A.
</ins></span><ins class="diff-chg">
Markup
Examples
</ins></h2><p><ins class="diff-chg">
The
JSON-LD
markup
examples
below
demonstrate
how
JSON-LD
can
be
used
to
express
semantic
data
marked
up
in
other
languages
such
as
RDFa,
Microformats,
and
Microdata.
These
sections
are
merely
provided
as
proof
</ins>
that
<del class="diff-old">contain
non-named
blank
nodes
</del>
<ins class="diff-chg">JSON-LD
</ins>
is
<del class="diff-old">supported.
</del>
<ins class="diff-chg">very
flexible
in
what
it
can
express
across
different
Linked
Data
approaches.
</ins>
</p>
<del class="diff-old">var myObj = { "@context" : { 
                "xsd" : "http://www.w3.org/2001/XMLSchema#",
                "name" : "http://xmlns.com/foaf/0.1/name",
                "age" : "http://xmlns.com/foaf/0.1/age",
                "homepage" : "http://xmlns.com/foaf/0.1/homepage",
                "@coerce": {
                   "xsd:nonNegativeInteger": "age",
                   "xsd:anyURI": "homepage"
                }
              },
              "name" : "Joe Jackson",
              "age" : "42",
              "homepage" : "http://example.org/people/joe" };
</del>
<div id="rdfa" class="section">
<h3>
<del class="diff-old">// Map the language-native object to JSON-LD
var
jsonldText
=
jsonld.normalize(myObj);
</del>
<span class="secno">
<ins class="diff-chg">A.1
</ins></span><ins class="diff-chg">
RDFa
</ins></h3>
<p>
<del class="diff-old">After
the
code
in
the
</del>
<ins class="diff-chg">The
following
</ins>
example
<del class="diff-old">above
has
executed,
the
jsonldText
value
will
be
(line-breaks
added
for
readability):
</del>
<ins class="diff-chg">describes
three
people
with
their
respective
names
and
homepages.
</ins>
</p>
<pre class="example">
<del class="diff-old">[{"http://xmlns.com/foaf/0.1/age":{"@datatype":"http://www.w3.org/2001/XMLSchema#nonNegativeInteger","@literal":"42"},
"http://xmlns.com/foaf/0.1/homepage":{"@iri":"http://example.org/people/joe"},
"http://xmlns.com/foaf/0.1/name":"Joe
Jackson"}]
</del>
<ins class="diff-chg">&lt;div <span class="diff">prefix="foaf: http://xmlns.com/foaf/0.1/"</span>&gt;
   &lt;ul&gt;
      &lt;li <span class="diff">typeof="foaf:Person"</span>&gt;
        &lt;a <span class="diff">rel="foaf:homepage" href="http://example.com/bob/" property="foaf:name" </span>&gt;Bob&lt;/a&gt;
      &lt;/li&gt;
      &lt;li <span class="diff">typeof="foaf:Person"</span>&gt;
        &lt;a <span class="diff">rel="foaf:homepage" href="http://example.com/eve/" property="foaf:name" </span>&gt;Eve&lt;/a&gt;
      &lt;/li&gt;
      &lt;li <span class="diff">typeof="foaf:Person"</span>&gt;
        &lt;a <span class="diff">rel="foaf:homepage" href="http://example.com/manu/" property="foaf:name" </span>&gt;Manu&lt;/a&gt;
      &lt;/li&gt;
   &lt;/ul&gt;
&lt;/div&gt;
</ins>
</pre>
<p>
<del class="diff-old">When
normalizing
xsd:double
values,
implementers
must
ensure
</del>
<ins class="diff-chg">An
example
JSON-LD
implementation
is
described
below,
however,
there
are
other
ways
to
mark-up
this
information
such
</ins>
that
the
<del class="diff-old">normalized
value
</del>
<ins class="diff-chg">context
</ins>
is
<ins class="diff-new">not
repeated.
</ins></p><pre class="example"><ins class="diff-new">
{
  "@context": { "foaf": "http://xmlns.com/foaf/0.1/"},
  "@subject": [
   {
     "@subject": "_:bnode1",
     "@type": "foaf:Person",
     "foaf:homepage": "http://example.com/bob/",
     "foaf:name": "Bob"
   },
   {
     "@subject": "_:bnode2",
     "@type": "foaf:Person",
     "foaf:homepage": "http://example.com/eve/",
     "foaf:name": "Eve"
   },
   {
     "@subject": "_:bnode3",
     "@type": "foaf:Person",
     "foaf:homepage": "http://example.com/manu/",
     "foaf:name": "Manu"
   }
  ]
}
</ins></pre></div><div id="microformats" class="section"><h3><span class="secno"><ins class="diff-new">
A.2
</ins></span><ins class="diff-new">
Microformats
</ins></h3><p><ins class="diff-new">
The
following
example
uses
</ins>
a
<del class="diff-old">string.
In
order
</del>
<ins class="diff-chg">simple
Microformats
hCard
example
</ins>
to
<del class="diff-old">generate
</del>
<ins class="diff-chg">express
how
</ins>
the
<del class="diff-old">string
from
a
double
value,
output
equivalent
to
</del>
<ins class="diff-chg">Microformat
is
represented
in
JSON-LD.
</ins></p><pre class="example"><ins class="diff-chg">
&lt;div class="vcard"&gt;
 &lt;a class="url fn" href="http://tantek.com/"&gt;Tantek Çelik&lt;/a&gt;
&lt;/div&gt;
</ins></pre><p><ins class="diff-chg">
The
representation
of
</ins>
the
<del class="diff-old">printf("%1.6e",
value)
function
</del>
<ins class="diff-chg">hCard
expresses
the
Microformat
terms
</ins>
in
<del class="diff-old">C
must
be
used
where
"%1.6e"
is
</del>
the
<del class="diff-old">string
formatter
</del>
<ins class="diff-chg">context
</ins>
and
<del class="diff-old">value
is
</del>
<ins class="diff-chg">uses
them
directly
for
</ins>
the
<del class="diff-old">value
</del>
<code>
<ins class="diff-chg">url
</ins></code><ins class="diff-chg">
and
</ins><code><ins class="diff-chg">
fn
</ins></code><ins class="diff-chg">
properties.
Also
note
that
the
Microformat
</ins>
to
<del class="diff-old">be
converted.
</del>
<ins class="diff-chg">JSON-LD
processor
has
generated
the
proper
URL
type
for
</ins><code><ins class="diff-chg">
http://tantek.com
</ins></code>.
</p>
<pre class="example">
<ins class="diff-new">{
  "@context": 
  {
    "vcard": "http://microformats.org/profile/hcard#vcard",
    "url": "http://microformats.org/profile/hcard#url",
    "fn": "http://microformats.org/profile/hcard#fn",
    "@coerce": { "xsd:anyURI": "url" }
  },
  "@subject": "_:bnode1",
  "@type": "vcard",
  "url": "http://tantek.com/",
  "fn": "Tantek Çelik"
}
</ins></pre></div><div id="microdata" class="section"><h3><span class="secno"><ins class="diff-new">
A.3
</ins></span><ins class="diff-new">
Microdata
</ins></h3>
<p>
<del class="diff-old">To
convert
the
</del>
<ins class="diff-chg">The
Microdata
example
below
expresses
book
information
as
</ins>
a
<del class="diff-old">double
value
in
JavaScript,
implementers
can
use
</del>
<ins class="diff-chg">Microdata
Work
item.
</ins></p><pre class="example"><ins class="diff-chg">
&lt;dl itemscope
    itemtype="http://purl.org/vocab/frbr/core#Work"
    itemid="http://purl.oreilly.com/works/45U8QJGZSQKDH8N"&gt;
 &lt;dt&gt;Title&lt;/dt&gt;
 &lt;dd&gt;&lt;cite itemprop="http://purl.org/dc/terms/title"&gt;Just a Geek&lt;/cite&gt;&lt;/dd&gt;
 &lt;dt&gt;By&lt;/dt&gt;
 &lt;dd&gt;&lt;span itemprop="http://purl.org/dc/terms/creator"&gt;Wil Wheaton&lt;/span&gt;&lt;/dd&gt;
 &lt;dt&gt;Format&lt;/dt&gt;
 &lt;dd itemprop="http://purl.org/vocab/frbr/core#realization"
     itemscope
     itemtype="http://purl.org/vocab/frbr/core#Expression"
     itemid="http://purl.oreilly.com/products/9780596007683.BOOK"&gt;
  &lt;link itemprop="http://purl.org/dc/terms/type" href="http://purl.oreilly.com/product-types/BOOK"&gt;
  Print
 &lt;/dd&gt;
 &lt;dd itemprop="http://purl.org/vocab/frbr/core#realization"
     itemscope
     itemtype="http://purl.org/vocab/frbr/core#Expression"
     itemid="http://purl.oreilly.com/products/9780596802189.EBOOK"&gt;
  &lt;link itemprop="http://purl.org/dc/terms/type" href="http://purl.oreilly.com/product-types/EBOOK"&gt;
  Ebook
 &lt;/dd&gt;
&lt;/dl&gt;
</ins></pre><p><ins class="diff-chg">
Note
that
</ins>
the
<del class="diff-old">following
snippet
</del>
<ins class="diff-chg">JSON-LD
representation
</ins>
of
<del class="diff-old">code:
</del>
<ins class="diff-chg">the
Microdata
information
stays
true
to
the
desires
of
the
Microdata
community
to
avoid
contexts
and
instead
refer
to
items
by
their
full
IRI.
</ins>
</p>
<pre class="example">
<del class="diff-old">// the variable 'value' below is the JavaScript native double value that is to be converted
(value).toExponential(6).replace(/(e(?:\+|-))([0-9])$/,
'$10$2')
</del>
<ins class="diff-chg">[
  {
    "@subject": "http://purl.oreilly.com/works/45U8QJGZSQKDH8N",
    "@type": "http://purl.org/vocab/frbr/core#Work",
    "http://purl.org/dc/terms/title": "Just a Geek",
    "http://purl.org/dc/terms/creator": "Whil Wheaton",
    "http://purl.org/vocab/frbr/core#realization": 
      ["http://purl.oreilly.com/products/9780596007683.BOOK", "http://purl.oreilly.com/products/9780596802189.EBOOK"]
  },
  {
    "@subject": "http://purl.oreilly.com/products/9780596007683.BOOK",
    "@type": "http://purl.org/vocab/frbr/core#Expression",
    "http://purl.org/dc/terms/type": "http://purl.oreilly.com/product-types/BOOK"
  },
  {
    "@subject": "http://purl.oreilly.com/products/9780596802189.EBOOK",
    "@type": "http://purl.org/vocab/frbr/core#Expression",
    "http://purl.org/dc/terms/type": "http://purl.oreilly.com/product-types/EBOOK"
  }
]
</ins>
</pre>
<del class="diff-old">When
data
needs
</del>
</div>
<div class="appendix section" id="mashing-up-vocabularies">
<h3>
<span class="secno">
<ins class="diff-chg">A.4
</ins></span><ins class="diff-chg">
Mashing
Up
Vocabularies
</ins></h3><p><ins class="diff-chg">
Developers
would
also
benefit
by
allowing
other
vocabularies
</ins>
to
be
<del class="diff-old">normalized,
JSON-LD
authors
should
not
use
values
</del>
<ins class="diff-chg">used
automatically
with
their
JSON
API.
There
are
over
200
Vocabulary
Documents
</ins>
that
are
<del class="diff-old">going
to
undergo
automatic
conversion.
This
is
due
to
</del>
<ins class="diff-chg">available
for
use
on
</ins>
the
<del class="diff-old">lossy
nature
</del>
<ins class="diff-chg">Web
today.
Some
</ins>
of
<del class="diff-old">xsd:double
values.
</del>
<ins class="diff-chg">these
vocabularies
are:
</ins>
</p>
<del class="diff-old">Round-tripping
data
can
be
problematic
if
we
mix
</del>
<ul>
<li>
<ins class="diff-chg">RDF
-
for
describing
information
about
objects
on
the
semantic
web.
</ins></li><li><ins class="diff-chg">
RDFS
-
for
expressing
things
like
labels
</ins>
and
<del class="diff-old">match
@coerce
rules
with
JSON-native
datatypes,
</del>
<ins class="diff-chg">comments.
</ins></li><li><ins class="diff-chg">
XSD
-
for
specifying
basic
types
</ins>
like
<del class="diff-old">integers.
Consider
the
following
code
example:
var myObj = { "@context" : { 
                "number" : "http://example.com/vocab#number",
                "@coerce": {
                   "xsd:nonNegativeInteger": "number"
                }
              },
              "number" : 42 };
// Map the language-native object to JSON-LD
var jsonldText = jsonld.normalize(myObj);
// Convert the normalized object back to a JavaScript object
var
myObj2
=
jsonld.parse(jsonldText);
At
this
point,
myObj2
</del>
<ins class="diff-chg">strings,
integers,
dates
</ins>
and
<del class="diff-old">myObj
will
have
different
values
</del>
<ins class="diff-chg">times.
</ins></li><li><ins class="diff-chg">
Dublin
Core
-
</ins>
for
<del class="diff-old">the
"number"
value.
myObj
will
be
the
number
42,
while
myObj2
will
be
the
string
"42".
This
type
</del>
<ins class="diff-chg">describing
creative
works.
</ins></li><li><ins class="diff-chg">
FOAF
-
for
describing
social
networks.
</ins></li><li><ins class="diff-chg">
Calendar
-
for
specifying
events.
</ins></li><li><ins class="diff-chg">
SIOC
-
for
describing
discussions
on
blogs
and
websites.
</ins></li><li><ins class="diff-chg">
CCrel
-
for
describing
Creative
Commons
and
other
types
</ins>
of
<del class="diff-old">data
round-tripping
error
</del>
<ins class="diff-chg">licenses.
</ins></li><li><ins class="diff-chg">
GEO
-
for
describing
geographic
location.
</ins></li><li><ins class="diff-chg">
VCard
-
for
describing
organizations
and
people.
</ins></li><li><ins class="diff-chg">
DOAP
-
for
describing
projects.
</ins></li></ul><p><ins class="diff-chg">
You
</ins>
can
<del class="diff-old">bite
developers.
We
are
currently
wondering
if
having
a
"coerce
validation"
phase
</del>
<ins class="diff-chg">use
these
vocabularies
</ins>
in
<del class="diff-old">the
parsing/normalization
phases
would
be
a
good
idea.
It
would
prevent
data
round-tripping
issues
</del>
<ins class="diff-chg">combination,
</ins>
like
<del class="diff-old">the
one
mentioned
above.
</del>
<ins class="diff-chg">so:
</ins>
</p>
<del class="diff-old">A.
The
Default
Context
</del>
<pre class="example">
<ins class="diff-chg">{
  "<span class="diff">@type</span>": "<span class="diff">foaf:Person</span>",
  "<span class="diff">foaf:name</span>": "Manu Sporny",
  "<span class="diff">foaf:homepage</span>": "http://manu.sporny.org/",
  "<span class="diff">sioc:avatar</span>": "http://twitter.com/account/profile_image/manusporny"
}
</ins></pre>
<p>
<del class="diff-old">The
default
context
is
provided
to
ensure
that
there
are
a
reasonable
set
of
prefixes
and
terms
available
to
all
JSON-LD
developers.
Mappings
specified
</del>
<ins class="diff-chg">Developers
can
also
specify
their
own
Vocabulary
documents
</ins>
by
<ins class="diff-new">modifying
</ins>
the
<del class="diff-old">default
</del>
<a class="tref internalDFN" title="active_context" href="#dfn-active_context">
<ins class="diff-chg">active
</ins>
context
</a>
<del class="diff-old">should
not
be
overwritten
by
JSON-LD
authors.
All
JSON-LD
processors
must
load
the
following
context
in
as
</del>
<ins class="diff-chg">in-line
using
</ins>
the
<del class="diff-old">intial
context
before
processing
JSON-LD
text.
</del>
<code>
<ins class="diff-chg">@context
</ins></code><ins class="diff-chg">
keyword,
like
so:
</ins>
</p>
<pre class="example">
{
<del class="diff-old">  "@context":
  {
    "@vocab": "",
    "rdf": "http://www.w3.org/1999/02/22-rdf-syntax-ns#",
    "rdfs": "http://www.w3.org/2000/01/rdf-schema#",
    "owl": "http://www.w3.org/2002/07/owl#",
    "xsd": "http://www.w3.org/2001/XMLSchema#",
    "dcterms": "http://purl.org/dc/terms/",
    "foaf": "http://xmlns.com/foaf/0.1/",
    "cal": "http://www.w3.org/2002/12/cal/ical#",
    "vcard": "http://www.w3.org/2006/vcard/ns# ",
    "geo": "http://www.w3.org/2003/01/geo/wgs84_pos#",
    "cc": "http://creativecommons.org/ns#",
    "sioc": "http://rdfs.org/sioc/ns#",
    "doap": "http://usefulinc.com/ns/doap#",
    "com": "http://purl.org/commerce#",
    "ps": "http://purl.org/payswarm#",
    "gr": "http://purl.org/goodrelations/v1#",
    "sig": "http://purl.org/signature#",
    "ccard": "http://purl.org/commerce/creditcard#"
    "@coerce": 
    {
      "xsd:anyURI": ["rdf:type", "rdf:rest", "foaf:homepage", "foaf:member"],
      "xsd:integer": "foaf:age"
    }
  }
</del>
  <span class="diff">"@context": { "myvocab": "http://example.org/myvocab#" }</span>,
<ins class="diff-chg">  "@type": "foaf:Person",
  "foaf:name": "Manu Sporny",
  "foaf:homepage": "http://manu.sporny.org/",
  "sioc:avatar": "http://twitter.com/account/profile_image/manusporny"<span class="diff">,
  "myvocab:personality": "friendly"</span>
</ins>
}
</pre>
<p>
<ins class="diff-new">The
</ins><code><ins class="diff-new">
@context
</ins></code><ins class="diff-new">
keyword
is
used
to
change
how
the
JSON-LD
processor
evaluates
key-value
pairs.
In
this
case,
it
was
used
to
map
one
string
('myvocab')
to
another
string,
which
is
interpreted
as
a
</ins><a class="tref internalDFN" title="IRI" href="#dfn-iri"><ins class="diff-new">
IRI
</ins></a>.<ins class="diff-new">
In
the
example
above,
the
</ins><code><ins class="diff-new">
myvocab
</ins></code><ins class="diff-new">
string
is
replaced
with
"
</ins><code><ins class="diff-new">
http://example.org/myvocab#
</ins></code><ins class="diff-new">
"
when
it
is
detected.
In
the
example
above,
"
</ins><code><ins class="diff-new">
myvocab:personality
</ins></code><ins class="diff-new">
"
would
expand
to
"
</ins><code><ins class="diff-new">
http://example.org/myvocab#personality
</ins></code><ins class="diff-new">
".
</ins></p><p><ins class="diff-new">
This
mechanism
is
a
short-hand
for
RDF,
called
a
CURIE,
and
provides
developers
an
unambiguous
way
to
map
any
JSON
value
to
RDF.
</ins></p><p></p>
</div>
<div class="appendix section" id="acknowledgements">
<h3>
<span class="secno">
<del class="diff-old">B.
</del>
<ins class="diff-chg">A.5
</ins>
</span>
Acknowledgements
</h3>
<p>
The
<del class="diff-old">editor
</del>
<ins class="diff-chg">editors
</ins>
would
like
to
thank
Mark
Birbeck,
who
provided
a
great
deal
of
the
<del class="diff-old">rationale
and
reasoning
</del>
<ins class="diff-chg">initial
push
</ins>
behind
the
JSON-LD
work
via
his
work
on
RDFj,
Dave
<del class="diff-old">Longley
</del>
<ins class="diff-chg">Longley,
Dave
Lehn
and
Mike
Johnson
</ins>
who
reviewed,
provided
feedback,
and
performed
several
<del class="diff-old">implementation
on
</del>
<ins class="diff-chg">implementations
of
</ins>
the
specification,
and
Ian
Davis,
who
created
RDF/JSON.
Thanks
also
to
Nathan
Rixham,
Bradley
P.
<del class="diff-old">Allen
</del>
<ins class="diff-chg">Allen,
Kingsley
Idehen,
Glenn
McDonald,
Alexandre
Passant,
Danny
Ayers,
Ted
Thibodeau
Jr.,
Olivier
Grisel,
Niklas
Lindström,
Markus
Lanthaler,
</ins>
and
Richard
Cyganiak
for
their
input
on
the
specification.
<ins class="diff-new">Another
huge
thank
you
goes
out
to
Dave
Longley
who
designed
many
of
the
algorithms
used
in
this
specification,
including
the
normalization
algorithm
which
was
a
monumentally
difficult
design
challenge.
</ins>
</p>
</div>
</div>
<div id="references" class="appendix section">
<h2>
<span class="secno">
<del class="diff-old">C.
</del>
<ins class="diff-chg">B.
</ins>
</span>
References
</h2>
<div id="normative-references" class="section">
<h3>
<span class="secno">
<del class="diff-old">C.1
</del>
<ins class="diff-chg">B.1
</ins>
</span>
Normative
references
</h3>
<dl class="bibliography">
<dt id="bib-BCP47">
[BCP47]
</dt>
<dd>
A.
Phillips,
M.
Davis.
<a href="http://tools.ietf.org/rfc/bcp/bcp47.txt">
<cite>
Tags
for
Identifying
Languages
</cite>
</a>
September
2009.
IETF
Best
Current
Practice.
URL:
<a href="http://tools.ietf.org/rfc/bcp/bcp47.txt">
http://tools.ietf.org/rfc/bcp/bcp47.txt
</a>
</dd>
<del class="diff-old">[RDF-API]
Manu
Sporny,
Benjamin
Adrian,
Nathan
Rixham;
et
al.
RDF
API
Latest.
W3C
Editor's
Draft.
URL:
http://www.w3.org/2010/02/rdfa/sources/rdf-api/
</del>
<dt id="bib-RDF-CONCEPTS">
[RDF-CONCEPTS]
</dt>
<dd>
Graham
Klyne;
Jeremy
J.
Carroll.
<a href="http://www.w3.org/TR/2004/REC-rdf-concepts-20040210">
<cite>
Resource
Description
Framework
(RDF):
Concepts
and
Abstract
Syntax.
</cite>
</a>
10
February
2004.
W3C
Recommendation.
URL:
<a href="http://www.w3.org/TR/2004/REC-rdf-concepts-20040210">
http://www.w3.org/TR/2004/REC-rdf-concepts-20040210
</a>
</dd>
<del class="diff-old">[RDF-INTERFACES]
</del>
<dt id="bib-RFC3986">
<ins class="diff-chg">[RFC3986]
</ins>
</dt>
<dd>
<del class="diff-old">Nathan
Rixham,
Manu
Sporny,
Benjamin
Adrian;
et
al.
</del>
<ins class="diff-chg">T.
Berners-Lee;
R.
Fielding;
L.
Masinter.
</ins><a href="http://www.ietf.org/rfc/rfc3986.txt">
<cite>
<del class="diff-old">RDF
Interfaces
</del>
<ins class="diff-chg">Uniform
Resource
Identifier
(URI):
Generic
Syntax.
</ins>
</cite>
</a>
<del class="diff-old">Latest.
W3C
Editor's
Draft.
</del>
<ins class="diff-chg">January
2005.
Internet
RFC
3986.
</ins>
URL:
<del class="diff-old">http://www.w3.org/2010/02/rdfa/sources/rdf-interfaces/
</del>
<a href="http://www.ietf.org/rfc/rfc3986.txt">
<ins class="diff-chg">http://www.ietf.org/rfc/rfc3986.txt
</ins>
</a>
</dd>
<dt id="bib-RFC3987">
[RFC3987]
</dt>
<dd>
M.
Dürst;
M.
Suignard.
<a href="http://www.ietf.org/rfc/rfc3987.txt">
<cite>
Internationalized
Resource
Identifiers
(IRIs).
</cite>
</a>
January
2005.
Internet
RFC
3987.
URL:
<a href="http://www.ietf.org/rfc/rfc3987.txt">
http://www.ietf.org/rfc/rfc3987.txt
</a>
</dd>
<dt id="bib-RFC4627">
[RFC4627]
</dt>
<dd>
D.
Crockford.
<a href="http://www.ietf.org/rfc/rfc4627.txt">
<cite>
The
application/json
Media
Type
for
JavaScript
Object
Notation
(JSON)
</cite>
</a>
July
2006.
Internet
RFC
4627.
URL:
<a href="http://www.ietf.org/rfc/rfc4627.txt">
http://www.ietf.org/rfc/rfc4627.txt
</a>
</dd>
<dt id="bib-WEBIDL">
<ins class="diff-new">[WEBIDL]
</ins></dt><dd><ins class="diff-new">
Cameron
McCormack.
</ins><a href="http://www.w3.org/TR/2008/WD-WebIDL-20081219"><cite><ins class="diff-new">
Web
IDL.
</ins></cite></a><ins class="diff-new">
19
December
2008.
W3C
Working
Draft.
(Work
in
progress.)
URL:
</ins><a href="http://www.w3.org/TR/2008/WD-WebIDL-20081219"><ins class="diff-new">
http://www.w3.org/TR/2008/WD-WebIDL-20081219
</ins></a></dd>
</dl>
</div>
<div id="informative-references" class="section">
<h3>
<span class="secno">
<del class="diff-old">C.2
</del>
<ins class="diff-chg">B.2
</ins>
</span>
Informative
references
</h3>
<dl class="bibliography">
<dt id="bib-ECMA-262">
<ins class="diff-new">[ECMA-262]
</ins></dt><dd><a href="http://www.ecma-international.org/publications/standards/Ecma-262.htm"><cite><ins class="diff-new">
ECMAScript
Language
Specification,
Third
Edition.
</ins></cite></a><ins class="diff-new">
December
1999.
URL:
</ins><a href="http://www.ecma-international.org/publications/standards/Ecma-262.htm"><ins class="diff-new">
http://www.ecma-international.org/publications/standards/Ecma-262.htm
</ins></a></dd>
<dt id="bib-MICRODATA">
[MICRODATA]
</dt>
<dd>
Ian
Hickson;
et
al.
<a href="http://www.w3.org/TR/microdata/">
<cite>
Microdata
</cite>
</a>
04
March
2010.
W3C
Working
Draft.
URL:
<a href="http://www.w3.org/TR/microdata/">
http://www.w3.org/TR/microdata/
</a>
</dd>
<dt id="bib-MICROFORMATS">
[MICROFORMATS]
</dt>
<dd>
<a href="http://microformats.org">
<cite>
Microformats
</cite>
</a>.
URL:
<a href="http://microformats.org">
http://microformats.org
</a>
</dd>
<dt id="bib-RDF-SCHEMA">
<ins class="diff-new">[RDF-SCHEMA]
</ins></dt><dd><ins class="diff-new">
Dan
Brickley;
Ramanathan
V.
Guha.
</ins><a href="http://www.w3.org/TR/2004/REC-rdf-schema-20040210"><cite><ins class="diff-new">
RDF
Vocabulary
Description
Language
1.0:
RDF
Schema.
</ins></cite></a><ins class="diff-new">
10
February
2004.
W3C
Recommendation.
URL:
</ins><a href="http://www.w3.org/TR/2004/REC-rdf-schema-20040210"><ins class="diff-new">
http://www.w3.org/TR/2004/REC-rdf-schema-20040210
</ins></a></dd>
<dt id="bib-RDFA-CORE">
[RDFA-CORE]
</dt>
<dd>
Shane
McCarron;
et
al.
<a href="http://www.w3.org/TR/2011/WD-rdfa-core-20110331">
<cite>
RDFa
Core
1.1:
Syntax
and
processing
rules
for
embedding
RDF
through
attributes.
</cite>
</a>
31
March
2011.
W3C
Working
Draft.
URL:
<a href="http://www.w3.org/TR/2011/WD-rdfa-core-20110331">
http://www.w3.org/TR/2011/WD-rdfa-core-20110331
</a>
</dd>
<dt id="bib-TURTLE">
<ins class="diff-new">[TURTLE]
</ins></dt><dd><ins class="diff-new">
David
Beckett,
Tim
Berners-Lee.
</ins><a href="http://www.w3.org/TeamSubmission/turtle/"><cite><ins class="diff-new">
Turtle:
Terse
RDF
Triple
Language.
</ins></cite></a><ins class="diff-new">
January
2008.
W3C
Team
Submission.
URL:
</ins><a href="http://www.w3.org/TeamSubmission/turtle/"><ins class="diff-new">
http://www.w3.org/TeamSubmission/turtle/
</ins>
</a>
</dd>
</dl>
</div>
</div>
</body>
</html>
